\input texinfo @c -*-texinfo-*-
@c =============================================================
@c = 翻 訳: 石川直太＠慶應義塾
@c = ただし、GPLに関しては引地美恵子（mieko@gnu.org）の管理して
@c = いる日本語訳（FSFの指示に従って弁護士のレビューを経たもの）
@c = を用いた。
@c =============================================================
@c
@c to print this file:
@c	jtex bison.texi
@c	texindex bison.cp
@c	jtex bison.texi
@c
@comment %**start of header
@setfilename bison-ja.info
@settitle Bison 1.25
@setchapternewpage odd

@iftex
@finalout
@end iftex

@c SMALL BOOK version   
@c This edition has been formatted so that you can format and print it in
@c the smallbook format. 
@c @smallbook

@c next time, consider using @set for edition number, etc...

@c Set following if you have the new `shorttitlepage' command
@c @clear shorttitlepage-enabled
@c @set shorttitlepage-enabled

@c infoファイル作成のため以下3行を追加（訳者）
@c Following 3 lines are added by naota to make info file.
@ifinfo
@clear shorttitlepage-enabled
@end ifinfo

@c ISPELL CHECK: done, 14 Jan 1993 --bob

@c Check COPYRIGHT dates.  should be updated in the titlepage, ifinfo
@c titlepage; should NOT be changed in the GPL.  --mew

@iftex
@syncodeindex fn cp
@syncodeindex vr cp
@syncodeindex tp cp
@end iftex
@ifinfo
@synindex fn cp
@synindex vr cp
@synindex tp cp
@end ifinfo
@comment %**end of header

@ifinfo
This file documents the Bison parser generator.

Copyright (C) 1988, 89, 90, 91, 92, 93, 1995 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

@ignore
Permission is granted to process this file through Tex and print the
results, provided the printed document carries copying permission
notice identical to this one except for the removal of this paragraph
(this paragraph not being relevant to the printed manual).

@end ignore
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided also that the
sections entitled ``GNU General Public License'' and ``Conditions for
Using Bison'' are included exactly as in the original, and provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that the sections entitled ``GNU General Public License'',
``Conditions for Using Bison'' and this permission notice may be
included in translations approved by the Free Software Foundation
instead of in the original English.
@end ifinfo

@ifset shorttitlepage-enabled
@shorttitlepage Bison
@end ifset
@titlepage
@c @title Bison
@title Bison入門
@subtitle The YACC-compatible Parser Generator
@c @subtitle YACC互換構文解析器生成ツール
@subtitle November 1995, Bison Version 1.25

@author by Charles Donnelly and Richard Stallman
@c 日本語訳：石川直太

@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1988, 89, 90, 91, 92, 93, 1995 Free Software
Foundation 

@sp 2
Published by the Free Software Foundation @*
59 Temple Place, Suite 330 @*
Boston, MA  02111-1307  USA @*
Printed copies are available for $15 each.@*
ISBN 1-882114-45-0

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

@ignore
Permission is granted to process this file through TeX and print the
results, provided the printed document carries copying permission
notice identical to this one except for the removal of this paragraph
(this paragraph not being relevant to the printed manual).

@end ignore
Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided also that the
sections entitled ``GNU General Public License'' and ``Conditions for
Using Bison'' are included exactly as in the original, and provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that the sections entitled ``GNU General Public License'',
``Conditions for Using Bison'' and this permission notice may be
included in translations approved by the Free Software Foundation
instead of in the original English.
@sp 2
Cover art by Etienne Suvasa.
@end titlepage
@page


@c =====================================================================
@node Top, Introduction, (dir), (dir)

@ifinfo
This manual documents version 1.25 of Bison.
@end ifinfo

@menu
* Introduction::      
* Conditions::        
* Copying::           The GNU General Public License says
                        how you can copy and share Bison

Tutorial sections:
* Concepts::          Basic concepts for understanding Bison.
* Examples::          Three simple explained examples of using Bison.

Reference sections:
* Grammar File::      Writing Bison declarations and rules.
* Interface::         C-language interface to the parser function @code{yyparse}.
* Algorithm::         How the Bison parser works at run-time.
* Error Recovery::    Writing rules for error recovery.
* Context Dependency::  What to do if your language syntax is too
                        messy for Bison to handle straightforwardly.
* Debugging::         Debugging Bison parsers that parse wrong.
* Invocation::        How to run Bison (to produce the parser source file).
* Table of Symbols::  All the keywords of the Bison language are explained.
* Glossary::          Basic concepts are explained.
* Index::             Cross-references to the text.

 --- The Detailed Node Listing ---

Bisonの概念

* Language and Grammar::  Languages and context-free grammars,
                            as mathematical ideas.
* Grammar in Bison::  How we represent grammars for Bison's sake.
* Semantic Values::   Each token or syntactic grouping can have
                        a semantic value (the value of an integer,
                        the name of an identifier, etc.).
* Semantic Actions::  Each rule can have an action containing C code.
* Bison Parser::      What are Bison's input and output,
                        how is the output used?
* Stages::            Stages in writing and running Bison grammars.
* Grammar Layout::    Overall structure of a Bison grammar file.

例

* RPN Calc::          Reverse polish notation calculator;
                        a first example with no operator precedence.
* Infix Calc::        Infix (algebraic) notation calculator.
                        Operator precedence is introduced.
* Simple Error Recovery::  Continuing after syntax errors.
* Multi-function Calc::  Calculator with memory and trig functions.
                           It uses multiple data-types for semantic values.
* Exercises::         Ideas for improving the multi-function calculator.

逆ポーランド記法電卓

* Decls: Rpcalc Decls.  Bison and C declarations for rpcalc.
* Rules: Rpcalc Rules.  Grammar Rules for rpcalc, with explanation.
* Lexer: Rpcalc Lexer.  The lexical analyzer.
* Main: Rpcalc Main.    The controlling function.
* Error: Rpcalc Error.  The error reporting function.
* Gen: Rpcalc Gen.      Running Bison on the grammar file.
* Comp: Rpcalc Compile. Run the C compiler on the output code.

@code{rpcalc}のための文法規則

* Rpcalc Input::      
* Rpcalc Line::       
* Rpcalc Expr::       

多機能電卓：@code{mfcalc}

* Decl: Mfcalc Decl.      Bison declarations for multi-function calculator.
* Rules: Mfcalc Rules.    Grammar rules for the calculator.
* Symtab: Mfcalc Symtab.  Symbol table management subroutines.

Bison文法ファイル

* Grammar Outline::   Overall layout of the grammar file.
* Symbols::           Terminal and nonterminal symbols.
* Rules::             How to write grammar rules.
* Recursion::         Writing recursive rules.
* Semantics::         Semantic values and actions.
* Declarations::      All kinds of Bison declarations are described here.
* Multiple Parsers::  Putting more than one Bison parser in one program.

Bison文法の概要

* C Declarations::    Syntax and usage of the C declarations section.
* Bison Declarations::  Syntax and usage of the Bison declarations section.
* Grammar Rules::     Syntax and usage of the grammar rules section.
* C Code::            Syntax and usage of the additional C code section.

言語の意味の定義

* Value Type::        Specifying one data type for all semantic values.
* Multiple Types::    Specifying several alternative data types.
* Actions::           An action is the semantic definition of a grammar rule.
* Action Types::      Specifying data types for actions to operate on.
* Mid-Rule Actions::  Most actions go at the end of a rule.
                      This says when, why and how to use the exceptional
                        action in the middle of a rule.

Bison宣言

* Token Decl::        Declaring terminal symbols.
* Precedence Decl::   Declaring terminals with precedence and associativity.
* Union Decl::        Declaring the set of all semantic value types.
* Type Decl::         Declaring the choice of type for a nonterminal symbol.
* Expect Decl::       Suppressing warnings about shift/reduce conflicts.
* Start Decl::        Specifying the start symbol.
* Pure Decl::         Requesting a reentrant parser.
* Decl Summary::      Table of all Bison declarations.

構文解析器のC言語インターフェイス

* Parser Function::   How to call @code{yyparse} and what it returns.
* Lexical::           You must supply a function @code{yylex} 
                        which reads tokens.
* Error Reporting::   You must supply a function @code{yyerror}.
* Action Features::   Special features for use in actions.

字句解析器関数@code{yylex}

* Calling Convention::  How @code{yyparse} calls @code{yylex}.
* Token Values::      How @code{yylex} must return the semantic value
                        of the token it has read.
* Token Positions::   How @code{yylex} must return the text position
                        (line number, etc.) of the token, if the
                        actions want that.
* Pure Calling::      How the calling convention differs
                        in a pure parser (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).

Bison構文解析器のアルゴリズム

* Look-Ahead::        Parser looks one token ahead when deciding what to do.
* Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
* Precedence::        Operator precedence works by resolving conflicts.
* Contextual Precedence::  When an operator's precedence depends on context.
* Parser States::     The parser is a finite-state-machine with stack.
* Reduce/Reduce::     When two rules are applicable in the same situation.
* Mystery Conflicts::  Reduce/reduce conflicts that look unjustified.
* Stack Overflow::    What happens when stack gets full.  How to avoid it.

演算子の優先順位

* Why Precedence::    An example showing why precedence is needed.
* Using Precedence::  How to specify precedence in Bison grammars.
* Precedence Examples::  How these features are used in the previous example.
* How Precedence::    How they work.

文脈依存性の処理

* Semantic Tokens::   Token parsing can depend on the semantic context.
* Lexical Tie-ins::   Token parsing can depend on the syntactic context.
* Tie-in Recovery::   Lexical tie-ins have implications for how
                        error recovery rules must be written.

Bisonの実行

* Bison Options::     All the options described in detail, 
			in alphabetical order by short options.
* Option Cross Key::  Alphabetical list of long options.
* VMS Invocation::    Bison command syntax on VMS.
@end menu

@c =====================================================================
@node Introduction, Conditions, Top, Top
@c @unnumbered Introduction
@unnumbered まえがき
@cindex introduction
@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)文脈自由文法の文法定義を、
その文法を解析するためのCで書かれたプログラムに変換する、
汎用の構文解析器生成ツールです。
あなたがBisonに熟練すれば、
簡単な電卓から複雑なプログラミング言語まで、
広い範囲の言語解析器を開発できるようになるでしょう。

@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の上位互換です。
正しく書かれたすべてのYacc文法を、変更なくBisonで処理できます。
Yaccに親しんでいるすべての人は、ちょっと考えるだけで、
Bisonを使えるようになるでしょう。
Bisonを使い、本書を理解するためには、
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を使うための基本的な概念を説明し、
2章では3つの具体例を示します。
BisonやYaccを知らない方は、
1章から読みはじめてください。
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によって開発され、
Richard StallmanがYacc互換にしました。
カーネギーメロン大学のWilfred Hansenが、
文字列リテラル@footnote{【訳注】2文字以上の文字列、たとえば@samp{==}を、
トークン名に使う機能。}といくつかの機能を追加しました。

@c This edition corresponds to version 1.25 of Bison.
本書は、Bisonのバージョン1.25に基づいています。

@unnumberedsec 日本語訳にあたって

本書は、株式会社アスキーの
支援を受けて、慶應義塾の石川直太
（@samp{naota@@sfc.keio.ac.jp、http://www.sfc.keio.ac.jp/~naota/}）
が翻訳しました。

なお、「GNU一般公有使用許諾書」の日本語訳については、
引地さんのところの日本語訳を使わせていただいたことを
ここに記して感謝いたします。

日本語訳したtexinfoファイルは、
@samp{http://www.ascii.co.jp/pub/GNU/bison-1.25-man-jp.tgz}
にあります。コマンドtexi2dviなどでdviファイルを生成したり、GNU Emacsでinfoファイルへ変換したりできます。

@c =====================================================================
@node Conditions, Copying, Introduction, Top
@c @unnumbered Conditions for Using 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の出力の
利用を許可するために、@code{yyparse}の配布条件を変えました。
それまでは、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プログランミングツールには、
このような制限がありません。
それらは、いつでも、フリーでないソフトウェアの開発に利用できます。
Bisonの利用条件が異なっていた理由は、特別な政治的判断によるものではありません。
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構文解析器ファイルには、
@code{yyparse}関数のためのコードである、
かなりの量のBisonのソースコードの一部分が、そのまま含まれます
（あなたが定義した文法によるアクションは、
この関数の1か所に挿入されるだけで、残りの関数は変わりません）。
われわれFSFが@code{yyparse}のコードにGPLを適用した結果、
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{ソフトウェアはフリーであるべきです。}
しかし、われわれは、Bisonの利用をフリーソフトウェアに限定したことは、
他のソフトウェアをフリーにしようとする人々を勇気づけるために、
少なからず役立っただろうと、結論を下しました。
そこで、われわれは、その他のGNUツールの現実的な利用条件に合わせて、
Bisonの現実的な利用条件を決定することにしました。


@c =============================================================
@c = <using 引地さんが管理するGPLの日本語訳>
@c =============================================================
@node Copying, Concepts, Conditions, Top
@c @unnumbered GNU GENERAL PUBLIC LICENSE
@c @center Version 2, June 1991
@unnumbered GNU一般公有使用許諾書
@center 1991年6月 バージョン2.0 

@display
Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
@c 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
675 Mass Ave, Cambridge, MA 02139, USA @footnote{【注意】
現在、このバージョン2の発行者(FSF)住所は、正式に新しい住所の @*
　59 Temple Place, Suite 330, Boston, MA 02111-1307, USA @*
に変わっている。}
@ifinfo
【注意】 現在、このバージョン2の発行者(FSF)住所は、正式に新しい住所の
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA に変わっている。
@end ifinfo

@c Everyone is permitted to copy and distribute verbatim copies
@c of this license document, but changing it is not allowed.
何人も、以下の内容を変更しないでそのまま複写する場合に限り、
本使用許諾書を複製したり頒布することができます。
@end display

@c @unnumberedsec Preamble
@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一般公有使用許諾は、
フリー・ソフトウェアを共有したり変更する自由をユーザに保証するためのもの、
即ちフリー・ソフトウェアがそのユーザ全てにとって
フリーであることを保証するためのものです。
本使用許諾は、Free Software Foundationのほとんど全てのソフトウェアに
適用されるだけでなく、
プログラムの作成者が本使用許諾に依るとした場合のそのプログラムにも
適用することができます。
（その他の Free Software Foundation のソフトウェアのいくつかは、
本許諾書ではなく、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.
 我々がフリー・ソフトウェアについて言う場合は
自由のことに言及しているのであって、価格のことではありません。
我々の一般公有使用許諾の各条項は、次の事柄を確実に実現することを
目的として立案されています。
@itemize @bullet
@item
フリー・ソフトウェアの複製物を自由に頒布できること
（そして、望むならあなたのこのサービスに対して対価を請求できること）。
@item
ソース・コードを実際に受け取るか、あるいは、
希望しさえすればそれを入手することが可能であること。
@item
入手したソフトウェアを変更したり、
新しいフリー・プログラムの一部として使用できること。
@item
以上の各内容を行なうことができるということをユーザ自身が知っていること。
@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.
 例えば、あなたがフリー・ソフトウェアの複製物を頒布する場合、
有償か無償かにかかわらず、
あなたは自分の持っている権利を全て相手に与えなければなりません。
あなたは、相手もまたソース・コードを受け取ったり入手できるということを
認めなければなりません。
さらにあなたは、彼らが自分たちの権利を知るように、
これらの条項を知らしめなければなりません。

@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.
 我々は次の２つの方法でユーザの権利を守ります。
（１）ソフトウェアに著作権を主張し、
（２）本使用許諾の条項の下で
ソフトウェアを複製・頒布・変更する権利をユーザに与えます。

@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.
 また、各作成者や我々自身を守るために、
本フリー・ソフトウェアが無保証であることを
全ての人々が了解している必要があります。
さらに、他の誰かによって変更されたソフトウェアが頒布された場合、
受領者はそのソフトウェアがオリジナル・バージョンではないということを
知らされる必要があります。
それは、他人の関与によって原開発者に対する評価が
影響されないようにするためです。

@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.
 最後に、どのフリー・プログラムもソフトウェア特許に絶えず脅かされています。
我々は、フリー・プログラムの再頒布者が個人的に特許権を取得し、
事実上そのプログラムを自分の財産にしてしまうという危険を
避けたいと願っています。
これを防ぐために我々は、いずれの特許も、
誰でも自由に使用できるように使用許諾されるべきか、
あるいは何人に対しても全く使用させないかの、
いずれかにすべきであることを明らかにしてきました。

@c   The precise terms and conditions for copying, distribution and
@c modification follow.
 複写・頒布・変更に対する正確な条項と条件を次に示します。

@iftex
@c @unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
@unnumberedsec GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件
@end iftex
@ifinfo
@c @center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
@center GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件
@end ifinfo

@enumerate 1
@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''.
本使用許諾は、本一般公有使用許諾の各条項に従って頒布されるという
著作権者からの告知文が表示されているプログラムやその他の作成物に適用されます。
以下において「プログラム」とは、そのようなプログラムや作成物を指すものとし、
また、「プログラム生成物」とは、上述した「プログラム」自身、または、
著作権法下における全ての派生物；すなわち、その「プログラム」の全部又は一部を、
そのまま又は変更して、且つ／又は他の言語に変換して、
内部に組み込んだ作成物を意味します。
（以下、言語変換は「変更」という用語の中に無条件に含まれるものとします。）
本使用許諾によって許諾を受ける者を「あなた」と呼びます。　

@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.
複製、頒布、変更以外の行為は本使用許諾の対象としません。
それらは本使用許諾の範囲外です。
「プログラム」を実行させる行為に関して制約はありません。
「プログラム」の出力は、
（「プログラム」を実行させて作成させたかどうかとは無関係に）
その内容が「プログラム生成物」である場合に限り本使用許諾の対象となります。
これが当てはまるかどうかは、「プログラム」が何をするものかに依ります。

@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.
あなたは、どのような媒体上へ複製しようとする場合であっても、
入手した「プログラム」のソース・コードを
そのままの内容で複写した上で適正な著作権表示と保証の放棄を明確、
且つ適正に付記する場合に限り、複製又は頒布することができます。
その場合、本使用許諾及び無保証に関する記載部分は、
全て元のままの形で表示してください。
また、「プログラム」の頒布先に対しては、
「プログラム」と共に本使用許諾書の写しを渡してください。

@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
@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:
次の各条件を全て満たしている限り、あなたは、
「プログラム」又はその一部分を変更して「プログラム生成物」とすることができ、
さらに、変更版や右作成物を上記第２項に従って複製又は頒布することもできます。

@enumerate a
@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
@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
@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.)
変更したプログラムが実行時に通常の対話的な方法で
コマンドを読むようになっているとすれば、
最も普通の方法で対話的にそのプログラムを実行する時に、
次の内容を示す文言がプリンタへ印字されるか、或いは画面に表示されること。
@itemize @bullet
@item
適切な著作権表示。
@item
無保証であること（あなたが独自に保証する場合は、その旨）。
@item
頒布を受ける者も、
本使用許諾と同一の条項に従って「プログラム」を再頒布できること。
@item
頒布を受ける者が本使用許諾書の写しを参照する方法。
（例外として、「プログラム」自体は対話的であっても起動時の文言を
通常は印字しないのならば、
あなたの「プログラム生成物」はこのような文言を印字する必要はありません。）
@end itemize
@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.
これらの要件は変更された作成物にも全て適用されます。
その変更版の或る部分が「プログラム」の派生物ではなく、
しかもそれ自体独立で異なる作成物だと合理的に考えられる場合、
あなたがそれらを別の作成物として頒布した時は、
本使用許諾とその条項はそれらの部分には適用されません。
しかし、それらを「プログラム生成物」の一部として頒布する場合は、
全体が本使用許諾の条項に従って頒布されなければならず、
使用許諾を受ける他の全ての者に対する許諾も
プログラム全体にわたって与えられなければならず、
結果として、誰が書いたかにかかわらず、
全ての部分に本使用許諾が適用されなければなりません。

@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
@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:
あなたは、以下のうちいずれか１つを満たす限り、
上記第２項及び第３項に従って「プログラム」
（又は、上記第３項で言及している「プログラム生成物」）を
オブジェクト・コード又は実行可能な形式で複製及び頒布することができます。

@enumerate a
@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,
対応する機械読み取り可能なソース・コード一式を一緒に引き渡すこと。
その場合、そのソース・コードの引き渡しは上記第２項及び第３項に従って、
通常ソフトウェアの交換に用いられる媒体で行なわれること。

@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,
少なくとも３年間の有効期間を定め、
且つその期間内であれば対応する機械読み取り可能なソース・コード一式の複製を、
ソース頒布に関わる実費以上の対価を要求せずに提供する旨、
及びその場合には上記第２項及び第３項に従って、
通常ソフトウェアの交換に用いられる媒体で提供される旨を記載した書面を、
第三者に一緒に引き渡すこと。

@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.)
対応するソース・コード頒布の申し出に際して、
あなたが得た情報を一緒に引き渡すこと。
（この選択肢は、営利を目的としない頒布であって、
且つあなたが上記の（ｂ）項に基づいて、
オブジェクト・コード或いは実行可能形式の
プログラムしか入手していない場合に限り適用される選択項目です。）
@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.
なお、ソース・コードとは、変更作業に適した記述形式を指します。
また、実行可能形式のファイルに対応するソース・コード一式とは、
それに含まれる全モジュールに対応する全てのソース・コード、
及びあらゆる関連のインタフェース定義ファイル、
及び実行を可能にするコンパイルとインストールの制御に関する記述を指します。
特別な例外として、実行可能なファイルが動作するオペレーティング・システムの
主要な構成要素（コンパイラ、カーネルなど）と共に
（ソース・コード又はバイナリのどちらかで）頒布されているものについては、
その構成要素自体が実行形式に付随していない場合に限り、
頒布されるソース・コードに含める必要はありません。

@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.
実行可能形式またはオブジェクト・コードの頒布が、
指示された場所からの複製のためのアクセス権の賦与である場合、
同じ場所からのソース・コードの複製のための同等なアクセス権を賦与すれば、
たとえ第三者にオブジェクト・コードと共にソースの複製を強いなくとも、
ソース・コードを頒布したものとみなします。

@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.
本使用許諾が明示的に許諾している場合を除き、あなたは、
「プログラム」を複製、変更、サブライセンス、頒布することができません。
本使用許諾に従わずに「プログラム」を複製、変更、サブライセンス、
頒布しようとする行為は、それ自体が無効であり、且つ、
本使用許諾があなたに許諾している「プログラム」の権利を自動的に消滅させます。
その場合、本使用許諾に従ってあなたから複製物やその権利を得ている第三者は、
本使用許諾に完全に従っている場合に限り、
引続き有効な使用権限を持つものとします。

@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.
あなたはまだ同意の印として署名していないので、
本使用許諾を受け入れる必要はありません。
しかし、あなたに「プログラム」又はその派生物を変更又は再頒布する許可を
与えるものは本使用許諾以外にはありません。
これらの行為は、あなたがもし本使用許諾を受け入れないのであれば、
法律によって禁じられます。
従って、あなたが「プログラム」（又は「プログラム生成物」）の変更又は頒布を
行えば、それ自体であなたは本使用許諾を受け入れ、且つ、
「プログラム」又はその「プログラム生成物」の複製、頒布、変更に
関するこれらの条項と条件の全てを受け入れたことを示します。

@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.
あなたが「プログラム」（又はその「プログラム生成物」）を再頒布すると自動的に、
その受領者は、元の使用許諾者から、本使用許諾の条項に従って「プログラム」を
複製、頒布、変更することを内容とする使用許諾を受けたものとします。
あなたは、受領者に許諾された権利の行使について、
さらに制約を加えることはできません。
あなたには、第三者に本使用許諾の受け入れを強いる責任はありません。

@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.
裁判所の判決、又は特許侵害の申し立て、又は（特許問題に限らない）
何らかの理由の結果として、あなたに課せられた条件が本使用許諾と
相入れないものであったとしても（裁判所の命令、契約、その他によるものであれ）、
本使用許諾の条件が免除されるものではありません。
本使用許諾による責務と、その他の何らかの関連責務を同時に満たす態様で
頒布することができないならば、
あなたは「プログラム」を全く頒布してはいけません。
例えば、特許権の内容が、あなたから直接又は間接に複製を受け取った全ての人に
使用料のないプログラムの再頒布を許さないものであれば、
あなたがかかる特許上の要請と本使用許諾の両方を満足させる方法は、
「プログラム」の頒布を完全に断念することだけです。

@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.
本条項の目的は、特許やその他の財産権を侵害したり、
そのような権利に基づく主張の妥当性を争うようにあなたに
勧めることではありません。
本条項の唯一の目的は、フリー・ソフトウェアの頒布システムの完全性を守ることで、
それは公有使用許諾の実践によって履行されます。
多くの人々が、このシステムの一貫した適用を信頼して、
このシステムを通じて頒布されている幅広い範囲のソフトウェアに惜しみない貢献を
してくれました。
作成者や寄贈者が他の何らかのシステムを通じてソフトウェアを
頒布したいと決めることは彼らの自由意志であり、
使用許諾を受ける者はその選択を強いることはできません。

@c This section is intended to make thoroughly clear what is believed to
@c be a consequence of the rest of this License.
本条項は、本使用許諾の他の条項の意味内容が何であるかを
完全に明らかにすることを意図しています。

@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.
「プログラム」の頒布・使用が、ある国において特許又は著作権で
保護されたインタフェースのどちらかで制限される場合、
「プログラム」を本使用許諾下においた原著作権保持者は、
その国を除外する旨の明示的な頒布地域制限を加え、
それ以外の（除外されない）国に限定して頒布が
許されるようにすることができます。
そのような場合、その制限を本使用許諾の本文に
あたかも書かれているかのように本使用許諾の中に組み入れられるものとします。

@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 は随時、本一般公有使用許諾の改訂版、
又は新版を公表することがあります。
そのような新しいバージョンは、
現行のバージョンと基本的に変わるところはありませんが、
新しい問題や懸案事項に対応するために細部では異なるかもしれません。

@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 が公表したどのバージョンでも選択することができます。

@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 へ書面を提出してください。
このような場合に対応するために我々は例外的処理をすることもありますが、
その判断基準となるのは、次の２つの目標の実現に合致するか否かという点です。
即ち、１つは我々のフリー・ソフトウェアの全ての派生物を
フリーな状態に保つことであり、もう１つはソフトウェアの共有と再利用とを
広く促進させることです。

@iftex
@c @heading NO WARRANTY
@heading 無保証
@end iftex
@ifinfo
@c @center NO WARRANTY
@center 無保証
@end ifinfo

@item
@c BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
@c FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW@.  EXCEPT WHEN
@c OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
@c PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
@c OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
@c MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE@.  THE ENTIRE RISK AS
@c TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU@.  SHOULD THE
@c PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
@c REPAIR OR CORRECTION.
「プログラム」は無償で使用許諾されますので、適用法令の範囲内で、
「プログラム」の保証は一切ありません。
著作権者やその他の第三者は全く無保証で「そのまま」の状態で、且つ、
明示か暗黙であるかを問わず一切の保証をつけないで提供するものとします。
ここでいう保証とは、市場性や特定目的適合性についての暗黙の保証も含まれますが、
それに限定されるものではありません。
「プログラム」の品質や性能に関する全てのリスクはあなたが負うものとします。
「プログラム」に欠陥があるとわかった場合、
それに伴う一切の派生費用や修理・訂正に要する費用は全てあなたの負担とします。

@item
@c IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
@c WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
@c REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
@c INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
@c OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
@c TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
@c YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
@c PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
@c POSSIBILITY OF SUCH DAMAGES.
適用法令の定め、又は書面による合意がある場合を除き、
著作権者や上記許諾を受けて「プログラム」の変更・再頒布を為し得る第三者は、
「プログラム」を使用したこと、
または使用できないことに起因する一切の損害について何らの責任も負いません。
著作権者や前記の第三者が、そのような損害の発生する可能性について
知らされていた場合でも同様です。
なお、ここでいう損害には通常損害、特別損害、偶発損害、間接損害が含まれます
（データの消失、又はその正確さの喪失、あなたや第三者が被った損失、
他のプログラムとのインタフェースの不適合化、等も含まれますが、
これに限定されるものではありません）。
@end enumerate

@iftex
@c @heading END OF TERMS AND CONDITIONS
@heading 以上
@end iftex
@ifinfo
@c @center END OF TERMS AND CONDITIONS
@center 以上
@end ifinfo

@c = 以下は日本語訳に関した部分
@heading 注意
 英文文書（GNU General Public License）を正式文書とする。
この和文文書は弁護士の意見を採り入れて、
できるだけ正確に英文文書を翻訳したものであるが、
法律的に有効な契約書ではない。

@unnumberedsec 和文文書自体の再配布に関して
 いかなる媒体でも次の条件がすべて満たされている場合に限り、
本和文文書をそのまま複写し配布することを許可する。
また、あなたは第三者に対して本許可告知と同一の許可を与える場合に限り、
再配布することが許可されています。
@itemize @bullet
@item
受領、配布されたコピーに著作権表示および本許諾告知が
前もって載せられていること。　
@item
コピーの受領者がさらに再配布する場合、
その配布者が本告知と同じ許可を与えていること。
@item
和文文書の本文を改変しないこと。
@end itemize

@page
@c @unnumberedsec How to Apply These Terms to Your New Programs
@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.
 そうするためには、プログラムに以下の表示をしてください。
その場合、無保証であるということを最も効果的に伝えるために、
ソース・ファイルの冒頭にその全文を表示すれば最も安全ですが、
その他の方法で表示する場合でも、「著作権表示」と全文を読み出す為の
アドレスへのポインタだけはファイル上に表示しておいてください。

@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{著作権者名}

@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 一般公有使用許諾の
「バージョン２」或いはそれ以降の各バージョンの中からいずれかを選択し、
そのバージョンが定める条項に従って本プログラムを
再頒布または変更することができます。

@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 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE@.  See the
@c GNU General Public License for more details.
本プログラムは有用とは思いますが、頒布にあたっては、
市場性及び特定目的適合性についての暗黙の保証を含めて、
いかなる保証も行ないません。
詳細については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一般公有使用許諾の写しを
受け取っているはずです。
そうでない場合は、@*
　Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA
@footnote{【注意】現在、このバージョン2の発行者(FSF)住所は、
正式に新しい住所の
59 Temple Place, Suite 330, Boston, MA 02111-1307, USA に変わっている。}
@ifinfo
【注意】 現在、このバージョン2の発行者(FSF)住所は、正式に新しい住所の
 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA に変わっている。
@end ifinfo
へ手紙を書いてください。
@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
@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.
Ｇｎｏｍｏｖｉｓｉｏｎ　バージョン６９、Ｃｏｐｙｒｉｇｈｔ（Ｃ）１９○○年 @var{著作権者名}
Gnomovision は完全に無保証です。詳細は show w とタイプしてください。
これはフリー・ソフトウェアなので、特定の条件の下でこれを再頒布する
ことができます。詳細は show c とタイプしてください。
@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}といった
呼び名でなくても構いません。
さらに、それらのコマンドはあなたのプログラムに合わせる為に、
マウスでクリックしたりメニュー形式にすることもできます。

@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:
また、必要と認めた場合には、あなたの雇い主
（あなたがプログラマとして働いている場合）や在籍する学校から、
そのプログラムに対する「著作権放棄」を認めた署名入りの書面を入手してください。
ここにその文例を載せます。名前は変えてください。

@smallexample
@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' 
（コンパイラにつなげるプログラム）についての著作権法上の全ての権利を放棄する。

@c @var{signature of Ty Coon}, 1 April 1989
@c Ty Coon, President of Vice
@var{Ｔｙ　Ｃｏｏｎ　の署名}，　１　Ａｐｒｉｌ　１９８９
Ｔｙ　Ｃｏｏｎ，　副社長
@end group
@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ライブラリ一般公有使用許諾書に従ってください。
@c =============================================================
@c = 以上のGPLの日本語訳に関しての問い合わせは、以下のアドレスに
@c = お願いいたします。
@c = mieko@gnu.org もしくは hikichi@gnu.org
@c =============================================================



@node Concepts, Examples, Copying, Top
@c @chapter The Concepts of 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やyaccの使い方を知らない方は、
この章を注意深く読むことから始めてください。

@menu
* Language and Grammar::  Languages and context-free grammars,
                            as mathematical ideas.
* Grammar in Bison::  How we represent grammars for Bison's sake.
* Semantic Values::   Each token or syntactic grouping can have
                        a semantic value (the value of an integer,
                        the name of an identifier, etc.).
* Semantic Actions::  Each rule can have an action containing C code.
* Bison Parser::      What are Bison's input and output,
                        how is the output used?
* Stages::            Stages in writing and running Bison grammars.
* Grammar Layout::    Overall structure of a Bison grammar file.
@end menu


@c =====================================================================
@node Language and Grammar, Grammar in Bison,  , Concepts
@c @section Languages and Context-Free Grammars
@section 言語と文脈自由文法

@cindex context-free grammar
@cindex grammar, context-free
@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が言語を解析するためには、その言語が
@dfn{文脈自由文法（context-free grammar）}で記述されている必要があります。
すなわち、1個以上の@dfn{文法グループ（syntactic groupings）}を定め、
その文法グループを部品から組み立てる規則を与える必要があります。
たとえば、C言語では、ある種のグループは「式」と呼ばれます。
式を作る規則の1つは、
「1つの式とは、別の式にマイナス記号を付けたものでもよい」かもしれません。
別の規則は、「1つの式とは、整数でもよい」かもしれません。
ここから解るように、規則はしばしば再帰的になりますが、
再帰を始めるための少なくとも1個の規則が必要です。

@cindex BNF
@cindex Backus-Naur form
@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''です。
これは、Algol 60言語を定義するために開発されました。
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で扱えるわけではありません。
LALR(1)だけを扱えます。
簡単に説明すると、ちょうど1個のトークンを先読みすることによって、
入力文字列の任意の部分を解析できる必要があるということです。
厳密に説明すると、これはLR(1)文法の説明で、
LALR(1)には簡単に説明できない追加の制限があります。
しかし、LALR(1)になれないLR(1)文法は、現実にはまれです。
より詳しい説明は
@xref{Mystery Conflicts, , Mysterious Reduce/Reduce Conflicts}。

@cindex symbols (abstract)
@cindex token
@cindex syntactic grouping
@cindex grouping, syntactic
@cindex シンボル
@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{非終端記号（nonterminal symbol）}といい、
@dfn{終端記号（terminal symbol）}または@dfn{トークン型（token type）}と呼ばれる
ものに分解できます。
本書では、1個の終端記号に対応する入力の一部分を@dfn{トークン（token）}、
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言語の終端記号には、「識別子」、「数値」、「文字列」、そして、
予約語、演算子、区切り記号のそれぞれに対する記号、
すなわち、「if」、「return」、「const」、「static」、「int」、「char」、
「プラス記号」、「開きブレース」、「閉じブレース」、「カンマ」、
などが含まれます
（これらのトークンは文字に分解できますが、
それは文法の問題ではなく、字句解析の問題です）。

@c Here is a simple C function subdivided into tokens:

次の例は、トークンに分解されたCの関数です。

@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'} */
square (x)      /* @r{識別子, 開きかっこ,} */
                /* @r{識別子, 閉じかっこ} */
     int x;     /* @r{予約語 `int', 識別子, セミコロン} */
@{               /* @r{開きブレース} */
  return x * x; /* @r{予約語 `return', 識別子,} */
                /* @r{アスタリスク, 識別子, セミコロン} */
@}               /* @r{閉じブレース} */
@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の文法で、非終端記号、「式」、「文」、「宣言」、
「関数定義」として表されます。
完全な文法では、上記の4つの意味を表現するために、
それぞれの非終端記号について、数十個の追加の言語構築が必要です。
上記の例で、関数定義は、宣言と文を含みます。
文の中で、それぞれの@samp{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}文について、
文法規則を形式ばらずに書くと、次のようになります。

@quotation
@c A `statement' can be made of a `return' keyword, an `expression' and a
@c `semicolon'.
「文」は、キーワード「@code{return}」、「式」、「セミコロン」から
作ることができる。
@end quotation

@noindent
@c There would be many other rules for `statement', one for each kind of
@c statement in C.
Cの各種の文について、「文」には多くの他の規則があるでしょう。

@cindex start symbol
@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.
@c
1つの非終端記号が、言語の全体を表現するように、
特別なものとして識別される必要があります。
これを@dfn{開始記号（start symbol）}と呼びます。
コンパイラでは、これは完全な入力プログラムを意味します。
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の式で、
Cのプログラムの有効な一部分ですが、
Cプログラム@emph{全体}としては無効です。
したがって、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構文解析器は、入力としてトークンの列を読み、
文法規則を使ってトークンをグループにします。
もし入力が有効であれば、最終的な結果として、トークンの列全体が
文法の開始記号である1つのグループの記号に還元されます。
もしわれわれがCの文法を使うならば、入力全体は
「定義と宣言の列」の必要があります。
もしそうでなければ、構文解析器が文法エラーを報告します。


@c =====================================================================
@node Grammar in Bison, Semantic Values, Language and Grammar, Concepts
@c @section From Formal Rules to Bison Input
@section 形式規則からBisonの入力へ
@cindex Bison grammar
@cindex Bison 文法
@cindex grammar, Bison
@cindex formal grammar
@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）は、数学的な構成です。
Bisonのために言語を定義するためには、Bisonの書式で文法を記述した
@dfn{Bison文法（Bison grammer）}ファイルを書く必要があります。
@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の入力の中で、
Cの識別子のような、1つの識別子として表現されます。
@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の表現は、
@dfn{トークン型（token type）}ともいいます。
トークン型は、C言語で使われるような識別子であるかもしれません。
通常、非終端記号からこれらを区別するために、大文字で書きます。
たとえば、@code{INTEGER}、@code{IDENTIFIER}、@code{IF}、@code{RETURN}
のように書きます。
言語の個々のキーワードを表す終端記号は、
キーワードを大文字に変換してから命名するべきです。
@cindex error
終端記号@code{error}は、エラーからの回復処理のために予約されています。
@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文字リテラルを表している
かもしれません。
トークンがちょうど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言語の文字列定数です。
詳細は@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つの式を持ちます。
たとえば、C言語の@code{return}文に対するBisonの規則があります。
クォート（'）で囲まれたセミコロンは、文に対するC言語の文法の一部分を表す、
1文字のリテラルトークンです。
クォートで囲まれていないセミコロンとコロンは、
あらゆる規則の中で使われる、Bisonの区切り文字です。

@example
stmt:   RETURN expr ';'
        ;
@end example

@noindent
@c @xref{Rules, ,Syntax of Grammar Rules}.
@xref{Rules, ,Syntax of Grammar Rules}。


@c =====================================================================
@node Semantic Values, Semantic Actions, Grammar in Bison, Concepts
@c @section Semantic Values
@section 意味値
@cindex semantic value
@cindex value, semantic
@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'という終端記号について言及するならば、
それは、文法的にそこに現れてよい@emph{任意の}整数型定数を意味します。
その定数の正確な値は、入力が解析される方法と無関係です。
もし、@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を区別できないコンパイラは、
役に立ちません。
そこで、Bison文法の中のそれぞれのトークンは、トークン型のほかに、
@dfn{意味値（semantic value）}を持ちます。詳細については、
@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{','}のように、
文法の中で定義される終端記号です。
これは、そのトークンが正しい位置に現れているか確かめ、
他のトークンとどのようにグループ化するか決めるために必要な、
すべての情報を含んでいます。
文法規則は、トークンの型以外の何も知りません。

@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{','}のような区切り記号であるトークンは、
意味値を持つ必要がありません）。

@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}で、
意味値が4であると分類されるかもしれません。
別の入力されたトークンは、同じ@code{INTEGER}型で、
値が3989であるかもしれません。
文法規則が@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つの式は、通常、
式の意味を表す木構造の意味値を持ちます。


@c =====================================================================
@node Semantic Actions, Bison Parser, Semantic Values, Concepts
@c @section Semantic Actions
@section 意味アクション
@cindex semantic actions
@cindex actions, semantic
@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文法の中では、文法規則は、
Cで書かれた@dfn{アクション（action）}を持てます。
そのルールへのマッチを構文解析器が認識するたびに、アクションが実行されます。
@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つの式の和でありうると仮定します。
構文解析器が和を認識すると、
部分式それぞれは、それがどのように構成されたかを表す意味値を持っています。
アクションは、新しく認識された合成式について、
同様の意味値を構成するべきです。

@c For example, here is a rule that says an expression can be the sum of
@c two subexpressions:

以下に、1つの式が2つの部分式の和となる規則の例を示します。

@example
expr: expr '+' expr   @{ $$ = $1 + $3; @}
        ;
@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個の部分式の値から、
式の和の意味値を生成する方法を示しています。


@c =====================================================================
@node Bison Parser, Stages, Semantic Actions, Concepts
@c @section Bison Output: the Parser File
@section Bisonの出力――構文解析器ファイル
@cindex Bison parser
@cindex Bison utility
@cindex lexical analyzer, purpose
@cindex parser
@cindex Bison構文解析器
@cindex Bisonユーティリティ
@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文法ファイルを指定します。
文法で記述された言語を解析する、Cのソースファイルが出力になります。
このファイルを@dfn{Bison構文解析器（Bison parser）}と呼びます。
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構文解析器の仕事は、文法規則に従って、トークンをグループ化することです。
たとえば、識別子と演算子から式を組み立てます。
このために、文法規則に対応するアクションを実行します。

@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）}と呼ばれる関数によって得られ、
その関数を（Cで書くような）なんらかの方法で与える必要があります。
Bison構文解析器は、新しいトークンを必要とするたびに、
字句解析器を呼び出します。
Bison構文解析器は、トークンの「内部」がなんであるか知りません
（しかし、トークンの意味値は関係します）。
一般に、字句解析器は、テキスト中の文字を解析してトークンを得ますが、
Bisonはその方法を知りません。
@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}という名前の、
文法を実装する関数を定義します。
この関数は、完全なCのプログラムを構成しません。
いくつかの関数を補ってやる必要があります。
1つは、字句解析器です。
もう1つは、エラーを報告するために構文解析器が呼び出す、
エラー報告関数です。
さらに、完全なCプログラムは@code{main}関数から実行を始める必要がありますので、
これを補って、そこから@code{yyparse}を呼び出してください。
@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構文解析器の中で使われるすべての変数と関数の名前は、
@samp{yy}または@samp{YY}で始まります。
これは、字句解析関数@code{yylex}とエラー報告関数@code{yyerror}および
構文解析関数@code{yyparse}のようなインターフェイス関数も含みます。
また、内部で使われる多数の識別子も同様です。
したがって、本書で定義されている場合を除いて、
Bison文法ファイルの中で@samp{yy}または@samp{YY}で始まる
Cの識別子の利用は避けるべきです。


@c =====================================================================
@node Stages, Grammar Layout, Bison Parser, Concepts
@c @section Stages in Using Bison
@section Bisonを使う手順
@cindex stages in using Bison
@cindex using Bison
@cindex 使用方法
@cindex Bisonの使用方法

@c The actual language-design process using Bison, from grammar specification
@c to a working compiler or interpreter, has these parts:

Bisonを使って、文法の定義から実際に動くコンパイラやインタープリタを作るまでの、
言語設計手順は、次のようになります。

@enumerate
@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.
@c
Bisonが認識できる形式で、文法を形式的に指定します
（@pxref{Grammar File, ,Bison Grammar Files}）。
言語の各文法規則に対して、
その規則のインスタンスが認識されたときに実行される
アクションを記述します。
アクションは、C言語の文の並びで書きます。

@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}}）。
Lexを使って生成することも可能ですが、本書ではLexの使い方については解説
していません。

@item
@c Write a controlling function that calls the Bison-produced parser.
@c
Bisonが生成した構文解析器を呼び出す、制御関数を書きます。

@item
@c Write error-reporting routines.
@c
エラー報告関数を書きます。

@end enumerate

@c To turn this source code as written into a runnable program, you
@c must follow these steps:

このソースプログラムを実行可能なプログラムにするために、
次の手順が必要です。

@enumerate
@item
@c Run Bison on the grammar to produce the parser.
@c
構文解析器を生成するために、Bisonを実行します。

@item
@c Compile the code output by Bison, as well as any other source files.
@c
Bisonが生成したソースプログラムとその他のソースプログラムを、
コンパイルします。

@item
@c Link the object files to produce the finished product.
@c
オブジェクトファイルをリンクして、最終的なプログラムを得ます。

@end enumerate


@c =====================================================================
@node Grammar Layout,  , Stages, Concepts
@c @section The Overall Layout of a Bison Grammar
@section Bison文法の全体像
@cindex grammar file
@cindex file format
@cindex format of grammar file
@cindex layout of Bison grammar
@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ユーティリティへの入力は、
@dfn{Bison文法ファイル（Bison grammar file）}です。
Bison文法ファイルの一般的な書式は、次のとおりです。

@example
%@{
@c @var{C declarations}
@var{C宣言部（C declarations）}
%@}

@c @var{Bison declarations}
@var{Bison宣言部（Bison declarations）}

%%
@c @var{Grammar rules}
@var{文法規則部（Grammar rules）}
%%
@c @var{Additional C code}
@var{追加のCプログラム部（Additional C code）}
@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{%@}}は、
ファイルを節に分ける区切り記号です。

@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宣言部}では、
アクションの中で使われる型と変数を定義できます。
マクロを定義するためのプリプロセッサディレクティブや、
ヘッダファイルをインクルードするための@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宣言部}には、終端記号、非終端記号、さらに、
演算子の優先順位、さまざまな記号の意味値のデータ型を記述できます。

@c The grammar rules define how to construct each nonterminal symbol from its
@c parts.

@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プログラム部}には、
あなたが望むCプログラムを記述できます。
よく字句解析関数@code{yylex}や
文法規則の中のアクションから呼ばれる関数をここに書きます。
単純なプログラムでは、@footnote{【訳注】他のファイルに書くのではなく}ここに
残りのプログラム全部を書きます。


@c =====================================================================
@node Examples, Grammar File, Concepts, Top
@c @chapter Examples
@chapter 例
@cindex simple examples
@cindex examples, simple
@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つ示します。
逆ポーランド記法電卓、算術（中置）記法電卓、多機能電卓です。
すべてBSD UNIX 4.3上でテストしました。
限定的ではありますが、対話的な電卓として利用可能です。

@c These examples are simple, but Bison grammars for real programming
@c languages are written the same way.

これらの例は単純ですが、現実のプログラミング言語に対する
Bison文法も、書き方は同じです。

@ifinfo
You can copy these examples out of the Info file and into a source file
to try them.
@end ifinfo

@menu
* RPN Calc::          Reverse polish notation calculator;
                        a first example with no operator precedence.
* Infix Calc::        Infix (algebraic) notation calculator.
                        Operator precedence is introduced.
* Simple Error Recovery::  Continuing after syntax errors.
* Multi-function Calc::  Calculator with memory and trig functions.
                           It uses multiple data-types for semantic values.
* Exercises::         Ideas for improving the multi-function calculator.
@end menu


@c =====================================================================
@node RPN Calc, Infix Calc,  , Examples
@c @section Reverse Polish Notation Calculator
@section 逆ポーランド記法電卓
@cindex reverse polish notation
@cindex polish notation calculator
@cindex rpcalc
@cindex calculator, simple
@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）}を使う
倍精度の電卓で、演算子を後に書きます。
この例は、演算子の優先順位の問題がないので、入門には適しています。
第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}とします。
Bisonの入力ファイルには、通常@samp{.y}という拡張子を付けます。

@menu
* Decls: Rpcalc Decls.  Bison and C declarations for rpcalc.
* Rules: Rpcalc Rules.  Grammar Rules for rpcalc, with explanation.
* Lexer: Rpcalc Lexer.  The lexical analyzer.
* Main: Rpcalc Main.    The controlling function.
* Error: Rpcalc Error.  The error reporting function.
* Gen: Rpcalc Gen.      Running Bison on the grammar file.
* Comp: Rpcalc Compile. Run the C compiler on the output code.
@end menu


@c =====================================================================
@node Rpcalc Decls, Rpcalc Rules,  , RPN Calc
@c @subsection Declarations for @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と同様に@samp{/*@dots{}*/}はコメントです。

@example
@c /* Reverse polish notation calculator. */
/* 逆ポーランド記法電卓 */

%@{
#define YYSTYPE double
#include <math.h>
%@}

%token NUM

@c %% /* Grammar rules and actions follow */
%% /* 文法規則とアクションが続く */
@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}）には、
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}ディレクティブで、トークンとグループの意味値に対する
Cのデータ型を指定するために、マクロ@code{YYSTYPE}を定義します
（@pxref{Value Type, ,Data Types of Semantic Values}）。
Bison構文解析器は、@code{YYSTYPE}に定義された型を使います。
定義しないと、@code{int}型が使用されます。
各トークンと式は、浮動小数点数である記録値を持つので、
ここでは@code{double}を指定します。

@c The @code{#include} directive is used to declare the exponentiation
@c function @code{pow}.

べき乗関数@code{pow}の宣言を使うために、
@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のためにトークン型についての情報を用意します
（@pxref{Bison Declarations, ,The Bison Declarations Section}）。
1文字リテラルでない終端記号は、ここで宣言する必要があります
（通常、1文字のリテラルを宣言する必要はありません）。
この例では、すべての算術演算子が1文字リテラルなので、
数値定数に対するトークン型@code{NUM}だけを、
終端記号として宣言します。


@c =====================================================================
@node Rpcalc Rules, Rpcalc Lexer, Rpcalc Decls, RPN Calc
@c @subsection Grammar Rules for @code{rpcalc}
@subsection @code{rpcalc}のための文法規則

@c Here are the grammar rules for the reverse polish notation calculator.

逆ポーランド記法電卓のための文法規則を示します。

@example
@c input:    /* empty */
input:    /* 空 */
        | input line
;

line:     '\n'
        | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
;

exp:      NUM             @{ $$ = $1;         @}
        | exp exp '+'     @{ $$ = $1 + $2;    @}
        | exp exp '-'     @{ $$ = $1 - $2;    @}
        | exp exp '*'     @{ $$ = $1 * $2;    @}
        | exp exp '/'     @{ $$ = $1 / $2;    @}
@c       /* Exponentiation */
      /* べき乗関数 */
        | exp exp '^'     @{ $$ = pow ($1, $2); @}
@c      /* Unary minus    */
      /* 単項のマイナス    */
        | exp 'n'         @{ $$ = -$1;        @}
;
%%
@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「言語」のグループは、
式（@code{exp}）と、入力行（@code{line}）と、
完全な入力の写し（@code{input}）です。
これらの非終端記号には、「論理和」という@samp{|}記号で区切られた、
いくつかの規則があります。
以下の項で、これらの規則の意味を説明します。

@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のプログラムです。
@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で書く必要がありますが、
Bisonには規則の間で意味値を受け渡しする方法があります。
それぞれのアクションで、擬似変数@code{$$}は、
その規則が構成しようとしているグループの意味値を示します。
@code{$$}に値を代入することが、アクションの主な仕事です。
規則の部品の意味値は、@code{$1}、@code{$2}などの
名前で参照されます。

@menu
* Rpcalc Input::      
* Rpcalc Line::       
* Rpcalc Expr::       
@end menu


@c =====================================================================
@node Rpcalc Input, Rpcalc Line,  , Rpcalc Rules
@c @subsubsection Explanation of @code{input}
@subsubsection @code{input}の説明

@c Consider the definition of @code{input}:

@code{input}の定義について考えます。

@example
@c input:    /* empty */
input:    /* 空 */
        | input line
;
@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}.

この定義の意味は、「完全な入力とは、空文字列であるか、あるいは、
完全な入力に入力行が続いたものである」ということです。
「完全な入力」が、それ自身を使って定義されていることに注意してください。
列の中で@code{input}が常に左端の記号なので、
このような定義を@dfn{左再帰（left recursive）}と呼びます。
@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{|}の間に記号がないので空です。
これは、（トークンを含まない）空の入力文字列にマッチします。
電卓を起動した直後に@kbd{Ctrl-d} @footnote{【訳注】UNIXの標準的なコンソールの
設定で、入力の終わりを示す制御文字で、MS-DOSでは代わりに@kbd{Ctrl-z}。}を
押しても、正しい入力と扱われるように、この規則を入れました。
通常、空に対応する選択肢を最初に置き、そこに@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}）は、
自明（空）でないすべての入力を扱います。
その意味は、「任意の数の行を読み込んだ後で、もし可能ならば、
もう1行読み込む」ということです。
左再帰が、この規則を繰り返しにします。
最初の選択肢が空の入力にマッチするので、
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}は、文法エラーが発生するか、あるいは、
字句解析器がもうトークンがないと判定するまで、
入力の処理を続けます。
ファイルの終わりで起きることについては、後で考慮します。


@c =====================================================================
@node Rpcalc Line, Rpcalc Expr, Rpcalc Input, Rpcalc Rules
@c @subsubsection Explanation of @code{line}
@subsubsection @code{line}の説明

@c Now consider the definition of @code{line}:

次に、@code{line}の定義について考えます。

@example
line:     '\n'
        | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
;
@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が空行を受け入れ、それに対応するアクションがないので、
無視することを示します。
第2の選択肢は、式の後に改行が続いたものです。
これが、rpcalcを有用にする選択肢です。
問い合わせの中の@code{exp}が、この選択肢に現れる最初の記号なので、
@code{exp}グループの意味値は、@code{$1}の値です。
アクションは、問い合わされた計算の結果である、
この値を表示します。

@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{line}に対応する意味値は、初期化されず、
その値は予想できなくなります。
もし、その値が使われると、この仕様はバグになりますが、われわれはこの値を使い
ません。ユーザーが入力した行に対する値を表示したら、
その値はもはや必要ありません。


@c =====================================================================
@node Rpcalc Expr,  , Rpcalc Line, Rpcalc Rules
@c @subsubsection Explanation of @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}グループは、いくつかの規則を持ち、
それぞれが式の種類に対応しています。
最初の規則は、数値そのものであるもっとも単純な式を処理します。
第2の規則は、2個の式に加算記号が続くような、加算式を処理します。
第3の規則は、減算式を処理する、といった具合です。

@example
exp:      NUM
        | exp exp '+'     @{ $$ = $1 + $2;    @}
        | exp exp '-'     @{ $$ = $1 - $2;    @}
        @dots{}
        ;
@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{|}を使っていますが、
次のように別々に書くことも可能です。

@example
exp:      NUM ;
exp:      exp exp '+'     @{ $$ = $1 + $2;    @} ;
exp:      exp exp '-'     @{ $$ = $1 - $2;    @} ;
        @dots{}
@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{$2}は式の第2の部品を表します。
第3の部品@code{'+'}は、意味値には関連する情報を持ちませんが、
もし値を持っていれば、@code{$3}として参照できます。
@code{yyparse}がこの規則を使って加算式を認識すると、
式全体の値として、2個の部分式の値の和が生成されます。
@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{$$}に複写します。
第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がこのように要求するわけではありません。
必要に応じて、空白、タブ、改行を置けます。
次のような書き方も可能です。

@example
exp   : NUM | exp exp '+' @{$$ = $1 + $2; @} | @dots{}
@end example

@c @noindent
@c means the same thing as this:

これは、次のリストと等価です。

@example
exp:      NUM
        | exp exp '+'    @{ $$ = $1 + $2; @}
        | @dots{}
@end example

@c @noindent
@c The latter, however, is much more readable.

しかし、後者のほうが可読性が優れています。


@c =====================================================================
@node Rpcalc Lexer, Rpcalc Main, Rpcalc Rules, RPN Calc
@c @subsection The @code{rpcalc} Lexical Analyzer
@subsection @code{rpcalc}字句解析器
@cindex writing a lexical analyzer
@cindex lexical analyzer, writing
@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構文解析器は、字句解析器を呼び出してトークンを得ます。
@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（逆ポーランド記法）電卓には、簡単な字句解析器のみが必要です。
この字句解析器は、空白とタブを読み飛ばし、
数値を読み込んで@code{double}型の@code{NUM}トークンとして返します。
数値の一部分ではないその他の文字は、独立のトークンです。
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規則の中でトークン型を表すために使われる文字列と同じものが、
その型の数値符号を表すCの式でもあります。
これには、2種類の働きがあります。
もし、トークン型が文字リテラルならば、
その数値符号は文字のASCII符号であり、
数値を表すために字句解析器の中と同じ文字リテラルを使えます。
もし、トークン型が識別子ならば、適切な番号を定義するCのマクロとして、
その識別子がBisonによって定義されます。
したがって、この例では、@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}に記憶され、
Bison構文解析器はそこを見にいきます
（@code{yylval}のCデータ型は、文法の最初で定義される@code{YYSTYPE}です。
@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が返されます
（Bisonは、正でない任意の値を入力の終わりと認識します）。

@c Here is the code for the lexical analyzer:

字句解析器のプログラムの例を示します。

@example
@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型の値をスタックに積んで
 * トークン「NUM」を返し、数値以外を読めば、その文字のアスキー符号を返す。
 * 空白とタブは読み飛ばされる。ファイルが終わると0を返す。
 */

#include <ctype.h>
@end group

@group
yylex ()
@{
  int c;

@c   /* skip white space  */
  /* 空白類を読み飛ばす  */
  while ((c = getchar ()) == ' ' || c == '\t')  
    ;
@end group
@group
@c  /* process numbers   */
  /* 数値を処理する   */
  if (c == '.' || isdigit (c))                
    @{
      ungetc (c, stdin);
      scanf ("%lf", &yylval);
      return NUM;
    @}
@end group
@group
  /* ファイルの終わりを処理する  */
  if (c == EOF)                            
    return 0;
  /* 1文字を返す */
  return c;                                
@}
@end group
@end example


@c =====================================================================
@node Rpcalc Main, Rpcalc Error, Rpcalc Lexer, RPN Calc
@c @subsection The Controlling Function
@subsection 制御関数
@cindex controlling function
@cindex main function in simple example
@cindex 制御関数
@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}関数を呼び出すことです。

@example
@group
main ()
@{
  yyparse ();
@}
@end group
@end example

@footnote{【訳注】古いK&R-C処理系を使う場合には前述の例のままでよいのですが、
ANSI-C処理系を使う場合には、@code{main}関数が返す値が
@code{int}型なので、次のように書くべきです。
他の関数についても同様です。本書の例のすべては古い書式で書かれています。

@example
@group
int main ()
@{
  return yyparse ();
@}
@end group
@end example
}

@c =====================================================================
@node Rpcalc Error, Rpcalc Gen, Rpcalc Main, RPN Calc
@c @subsection The Error Reporting Routine
@subsection エラー報告関数
@cindex error reporting routine
@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{"parse error"}）を
表示するために、エラー報告関数@code{yyerror}を呼び出します。

@example
@group
#include <stdio.h>

@c yyerror (s)  /* Called by yyparse on error */
yyerror (s)  /* エラーが起きるとyyparseから呼び出される */
     char *s;
@{
  printf ("%s\n", s);
@}
@end group
@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構文解析器は、
文法に適切なエラー規則（@pxref{Error Recovery}）があれば、
エラーから回復し、解析を継続できます。
そうでない場合には、@code{yyparse}が0でない値を返します。
この例では、エラー規則を書いていないので、
不正な入力はすべて電卓プログラムを終了させます。
これは、実際の電卓としてはきれいな動作ではありませんが、
最初の例としては十分です。


@c =====================================================================
@node Rpcalc Gen, Rpcalc Compile, Rpcalc Error, RPN Calc
@c @subsection Running Bison to Make the Parser
@subsection 構文解析器を生成するためにBisonを実行
@cindex running Bison (introduction)
@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を実行する前に、
1つ以上のソースファイルのすべてをどのように整えるか、
決める必要があります。
このような単純な例では、すべてを1個のファイルに詰め込む方法が
いちばん簡単です。
@code{yylex}、@code{yyerror}、@code{main}の定義を、
ファイルの「追加のCコード」部の最後に置きます
（@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}を使うでしょう。

@c With all the source in a single file, you use the following command to
@c convert it into a parser file:

1つのファイルにすべてのソースが入っているならば、
次のコマンドで、それを構文解析器ファイルに変換できます。

@example
bison @var{file_name}.y
@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}（逆ポーランド記法電卓）と
呼ばれています。Bisonは、元のファイル名から@samp{.y}を取り除いて、
@file{@var{file_name}.tab.c}というファイルを生成します。
Bisonが出力したファイルには、@code{yyparse}のソースコードが含まれています。
入力ファイル中の追加の関数（@code{yylex}、@code{yyerror}、@code{main}）は、
出力にそのまま複写されます。


@c =====================================================================
@node Rpcalc Compile,  , Rpcalc Gen, RPN Calc
@c @subsection Compiling the Parser File
@subsection 構文解析器ファイルのコンパイル
@cindex compiling the parser
@cindex コンパイル

@c Here is how to compile and run the parser file:

構文解析器ファイルをコンパイルする方法を示します。
@footnote{【訳注】UNIX上で@code{cc}コマンドを使ってコンパイルする方法を示します。}

@example
@group
@c # @r{List files in current directory.}
# @r{カレントディレクトリのファイルの一覧を見る。}
% ls
rpcalc.tab.c  rpcalc.y
@end group

@group
@c # @r{Compile the Bison parser.}
# @r{Bison構文解析器をコンパイルする。}
@c # @r{@samp{-lm} tells compiler to search math library for @code{pow}.}
# @r{数学ライブラリ内の@code{pow}関数をリンクするために@samp{-lm}を指定する。}
% cc rpcalc.tab.c -lm -o rpcalc
@end group

@group
@c # @r{List files again.}
# @r{再び、ファイルの一覧を見る。}
% ls
rpcalc  rpcalc.tab.c  rpcalc.y
@end group
@end example

@c The file @file{rpcalc} now contains the executable code.  Here is an
@c example session using @code{rpcalc}.

できた@file{rpcalc}ファイルは、実行可能プログラムです。
@code{rpcalc}を実行させる例を示します。

@example
% rpcalc
4 9 +
13
3 7 + 3 4 5 *+-
-13
@c 3 7 + 3 4 5 * + - n              @r{Note the unary minus, @samp{n}}
3 7 + 3 4 5 * + - n              @r{単項マイナスを示す@samp{n}に注意}
13
5 6 / 4 n +
-3.166666667
@c 3 4 ^                            @r{Exponentiation}
3 4 ^                            @r{べき乗関数}
81
@c ^D                               @r{End-of-file indicator}
^D                               @r{入力の終わり}
%
@end example


@c =====================================================================
@node Infix Calc, Simple Error Recovery, RPN Calc, Examples
@c @section Infix Notation Calculator: @code{calc}
@section 中間記法電卓：@code{calc}
@cindex infix notation calculator
@cindex calc
@cindex calculator, infix notation
@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を変更します。
中間記法には、演算子の優先順位の概念と、
適切な深さに入れ子できるかっこが必要です。
中間記法電卓を作るためのBisonソースファイル
@file{calc.y}を示します。

@example
@c /* Infix notation calculator--calc */
/* 中間記法電卓 -- calc */

%@{
#define YYSTYPE double
#include <math.h>
%@}

@c /* BISON Declarations */
/* BISON宣言 */
%token NUM
%left '-' '+'
%left '*' '/'
@c %left NEG     /* negation--unary minus */
%left NEG     /* negation--単項マイナス */
@c %right '^'    /* exponentiation        */
%right '^'    /* べき乗関数        */

@c /* Grammar follows */
/* 文法規則が続く */
%%
@c input:    /* empty string */
input:    /* 空文字列 */
        | input line
;

line:     '\n'
        | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
;

exp:      NUM                @{ $$ = $1;         @}
        | exp '+' exp        @{ $$ = $1 + $3;    @}
        | exp '-' exp        @{ $$ = $1 - $3;    @}
        | exp '*' exp        @{ $$ = $1 * $3;    @}
        | exp '/' exp        @{ $$ = $1 / $3;    @}
        | '-' exp  %prec NEG @{ $$ = -$2;        @}
        | exp '^' exp        @{ $$ = pow ($1, $3); @}
        | '(' exp ')'        @{ $$ = $2;         @}
;
%%
@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}関数は、
前の例のものと同じです。

@c There are two important new features shown in this code.

このプログラムには、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宣言部）では、
@code{%left}がトークンの型とそれが左結合演算子であると宣言します。
宣言@code{%left}と@code{%right}（右結合演算子）は、
結合性を持たないトークン型名を宣言するために使われる@code{%token}の代わりに
なります
（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{/}」と続きます。
@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つの重要な特徴は、単項の負の演算子のために文法部分にある
@code{%prec}です。
@code{%prec}は、単純にBisonに対して、規則@samp{| '-' exp}は
@code{NEG}と同じ優先順位を持つように指示し、
この例ではどちらも2番目に高い優先順位を持ちます。

@c Here is a sample run of @file{calc.y}:

以下は@file{calc.y}の実行例です。

@need 500
@example
% calc
4 + 4.5 - (34/(8*3+-3))
6.880952381
-56 + 2
-54
3 ^ 2
9
@end example


@c =====================================================================
@node Simple Error Recovery, Multi-function Calc, Infix Calc, Examples
@c @section Simple Error Recovery
@section 単純なエラー回復
@cindex error recovery, simple
@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）}、
つまり、構文エラーを検出した後で構文解析を続ける方法については
言及していませんでした。
今までに扱ったことは、@code{yyerror}を使ってエラーを報告することだけでした。
@code{yyerror}を呼び出した後で、特に指定しないと@code{yyparse}は
処理を終わることを思い出してください。
つまり、エラーを含む入力行が、電卓プログラムを終了させます。
この欠陥をどのように改善するか示しましょう。

@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}があります。
次の例では、@code{line}に対する選択肢群に@code{error}を追加する
方法を示します。

@example
@group
line:     '\n'
        | exp '\n'   @{ printf ("\t%.10g\n", $1); @}
        | error '\n' @{ yyerrok;                  @}
;
@end group
@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

文法へのこの追加によって、構文解析エラーが発生した場合に、
簡単なエラー回復が可能になります。
評価不可能な式が読み込まれると、
@code{line}に対する第3の規則によってエラーが認識され、
構文解析が続けられます。
この場合にも、関数@code{yyerror}は呼び出され、
メッセージを表示します。
アクションは、
Bisonによって自動的に定義されるマクロである@code{yyerrok}文を実行します。
これはエラー回復の完了を意味します（@pxref{Error Recovery}）。
@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による除算は、例外シグナルを発生し、通常は致命的です。
実際の電卓プログラムは、このシグナルをつかまえて、@code{longjmp}を使って
@code{main}に戻り、入力行の構文解析を続ける必要があります。
さらに、現在の入力行の残りは破棄されるべきです。
しかし、これらの問題は、Bisonのプログラムに固有の問題ではないので、
本書では解説しません。


@c =====================================================================
@node Multi-function Calc, Exercises, Simple Error Recovery, Examples
@c @section Multi-Function Calculator: @code{mfcalc}
@section 多機能電卓：@code{mfcalc}
@cindex multi-function calculator
@cindex mfcalc
@cindex calculator, multi-function
@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の基礎についての説明が終わったので、より高度な話題に移りましょう。
前述の電卓は、5種類の機能、@samp{+}、@samp{-}、@samp{*}、@samp{/}、
@samp{^}を持っています。
この電卓に、その他の数学関数、たとえば、@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文字リテラルならば簡単です。
字句解析器@code{yylex}は、数値以外のすべての文字をトークンとして渡すので、
追加の演算子に対応する文法規則を追加するだけです。
しかし、次のような表記方法の、より柔軟な組み込み関数が必要です。

@example
@c @var{function_name} (@var{argument})
@var{関数名} (@var{引数})
@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:

さらに、電卓にメモリを追加し、名前付き変数を作り、そこに値を記憶し、
後で使えるようにしましょう。
以下に多機能電卓を使う作業の例を示します。

@example
% mfcalc
pi = 3.141592653589
3.1415926536
sin(pi)
0.0000000000
alpha = beta1 = 2.3
2.3000000000
alpha
2.3000000000
ln(alpha)
0.8329091229
exp(ln(beta1))
2.3000000000
%
@end example

@c Note that multiple assignment and nested function calls are permitted.

複数の代入@footnote{【訳注】例の@samp{alpha = beta1 = 2.3}}と
関数の入れ子@footnote{【訳注】例の@samp{exp(ln(beta1))}}が
許されることに注意してください。

@menu
* Decl: Mfcalc Decl.      Bison declarations for multi-function calculator.
* Rules: Mfcalc Rules.    Grammar rules for the calculator.
* Symtab: Mfcalc Symtab.  Symbol table management subroutines.
@end menu


@c =====================================================================
@node Mfcalc Decl, Mfcalc Rules,  , Multi-function Calc
@c @subsection Declarations for @code{mfcalc}
@subsection @code{mfcalc}のための定義

@c Here are the C and Bison declarations for the multi-function calculator.

以下には、多機能電卓のための、CとBisonの宣言があります。

@smallexample
%@{
@c #include <math.h>  /* For math functions, cos(), sin(), etc. */
#include <math.h>  /* cos(), sin()などの数学関数のため */
@c #include "calc.h"  /* Contains definition of `symrec'        */
#include "calc.h"  /* `symrec'の定義を含む             */
%@}
%union @{
@c double     val;  /* For returning numbers.                   */
double     val;    /* 数値を返すため                   */
@c symrec  *tptr;   /* For returning symbol-table pointers      */
symrec  *tptr;     /* 記号表へのポインタを返すため     */
@}

@c %token <val>  NUM        /* Simple double precision number   */
%token <val>  NUM        /* 単純な倍精度数値 */
@c %token <tptr> VAR FNCT   /* Variable and Function            */
%token <tptr> VAR FNCT   /* 変数と関数       */
%type  <val>  exp

%right '='
%left '-' '+'
%left '*' '/'
@c %left NEG     /* Negation--unary minus */
%left NEG     /* 否定 -- 単項の負 */
@c %right '^'    /* Exponentiation        */
%right '^'    /* べき乗           */

@c /* Grammar follows */
/* 文法が続く */

%%
@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つの機能を使っています。
これらの機能によって、意味値がいろいろなデータ型を持てます
（@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{exp}と@code{NUM}のための）倍精度浮動小数点型と、
記号表の項目へのポインタです。
@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).

値がいろいろな型を持つことができるので、
意味値を使うそれぞれの文法記号に対して、
型を関連づける必要があります。
これらの記号は@code{NUM}、@code{VAR}、@code{FNCT}、@code{exp}です。
それらの宣言は、不等号で囲まれた（@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}がトークン型の宣言に使われるのと同じように、
@code{%type}が非終端記号の宣言に使われるようにします。
非終端記号は通常それらを定義する規則によって暗黙に宣言されるので、
@code{%type}をその規則よりも先に使ってはいけません。
しかし、@code{exp}は、その値の型を指定するので、
明示的に宣言する必要があります。
@xref{Type Decl, ,Nonterminal Symbols}。


@c =====================================================================
@node Mfcalc Rules, Mfcalc Symtab, Mfcalc Decl, Multi-function Calc
@c @subsection Grammar Rules for @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{VAR}、@code{FUNCT}に関連する3つの規則が新しいものです。

@smallexample
@c input:   /* empty */
input:   /* 空 */
        | input line
;

line:
          '\n'
        | exp '\n'   @{ printf ("\t%.10g\n", $1); @}
        | error '\n' @{ yyerrok;                  @}
;

exp:      NUM                @{ $$ = $1;                         @}
        | VAR                @{ $$ = $1->value.var;              @}
        | VAR '=' exp        @{ $$ = $3; $1->value.var = $3;     @}
        | FNCT '(' exp ')'   @{ $$ = (*($1->value.fnctptr))($3); @}
        | exp '+' exp        @{ $$ = $1 + $3;                    @}
        | exp '-' exp        @{ $$ = $1 - $3;                    @}
        | exp '*' exp        @{ $$ = $1 * $3;                    @}
        | exp '/' exp        @{ $$ = $1 / $3;                    @}
        | '-' exp  %prec NEG @{ $$ = -$2;                        @}
        | exp '^' exp        @{ $$ = pow ($1, $3);               @}
        | '(' exp ')'        @{ $$ = $2;                         @}
;
@c /* End of grammar */
/* 文法の終わり */
%%
@end smallexample


@c =====================================================================
@node Mfcalc Symtab,  , Mfcalc Rules, Multi-function Calc
@c @subsection The @code{mfcalc} Symbol Table
@subsection @code{mfcalc}の記号表
@cindex symbol table example
@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宣言には影響しませんが、
追加の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}にあります。
関数と変数の両方を表に置くことができます。

@smallexample
@group
@c /* Data type for links in the chain of symbols.      */
/* 記号表のリンクを表すデータ型                 */
struct symrec
@{
@c  char *name;  /* name of symbol                     */
  char *name;  /* 記号の名前                    */
@c  int type;    /* type of symbol: either VAR or FNCT */
  int type;    /* 記号の種類：VARまたはFNCT     */
  union @{
@c    double var;           /* value of a VAR          */
    double var;           /* VARの値            */
@c    double (*fnctptr)();  /* value of a FNCT         */
    double (*fnctptr)();  /* FNCTの値           */
  @} value;
@c  struct symrec *next;    /* link field              */
  struct symrec *next;    /* 次の項目へのリンク */
@};
@end group

@group
typedef struct symrec symrec;

@c /* The symbol table: a chain of `struct symrec'.     */
/* `struct symrec'のリンクである記号表          */
extern symrec *sym_table;

symrec *putsym ();
symrec *getsym ();
@end group
@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{init_table}を呼びます。
@code{main}と@code{init_table}を以下に示します。

@smallexample
@group
#include <stdio.h>

main ()
@{
  init_table ();
  yyparse ();
@}
@end group

@group
@c yyerror (s)  /* Called by yyparse on error */
yyerror (s)  /* エラーがあるとyyparseから呼び出される */
     char *s;
@{
  printf ("%s\n", s);
@}

struct init
@{
  char *fname;
  double (*fnct)();
@};
@end group

@group
struct init arith_fncts[]
  = @{
      "sin", sin,
      "cos", cos,
      "atan", atan,
      "ln", log,
      "exp", exp,
      "sqrt", sqrt,
      0, 0
    @};

@c /* The symbol table: a chain of `struct symrec'.  */
/* 記号表：`struct symrec'のリスト       */
symrec *sym_table = (symrec *)0;
@end group

@group
@c init_table ()  /* puts arithmetic functions in table. */
init_table ()  /* 数学関数を表に登録する */
@{
  int i;
  symrec *ptr;
  for (i = 0; arith_fncts[i].fname != 0; i++)
    @{
      ptr = putsym (arith_fncts[i].fname, FNCT);
      ptr->value.fnctptr = arith_fncts[i].fnct;
    @}
@}
@end group
@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個の重要な関数があります。
関数@code{putsym}は、登録すべきオブジェクトの
名前と型（@code{VAR}や@code{FNCT}）を渡されます。
オブジェクトはリストの先頭にリンクされ、
オブジェクトへのポインタが返されます。
関数@code{getsym}は、検索すべき記号の名前を渡されます。
もし見つかれば記号へのポインタが返され、
見つからなければ0が返されます。

@smallexample
symrec *
putsym (sym_name,sym_type)
     char *sym_name;
     int sym_type;
@{
  symrec *ptr;
  ptr = (symrec *) malloc (sizeof (symrec));
  ptr->name = (char *) malloc (strlen (sym_name) + 1);
  strcpy (ptr->name,sym_name);
  ptr->type = sym_type;
@c  ptr->value.var = 0; /* set value to 0 even if fctn.  */
  ptr->value.var = 0; /* 関数の場合にも値を0にする */
  ptr->next = (struct symrec *)sym_table;
  sym_table = ptr;
  return ptr;
@}

symrec *
getsym (sym_name)
     char *sym_name;
@{
  symrec *ptr;
  for (ptr = sym_table; ptr != (symrec *) 0;
       ptr = (symrec *)ptr->next)
    if (strcmp (ptr->name,sym_name) == 0)
      return ptr;
  return 0;
@}
@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文字の算術演算子を
認識する必要があります。
英字で始まり英数字からなる文字列は、記号表にどう書かれているかに応じて、
変数と関数のどちらとも認識されます。

@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{VAR}または@code{FNCT}）が、
@code{yyparse}に返されます。
名前がまだ表になければ、@code{putsym}を使って、
@code{VAR}として登録されます。
そして、ポインタと型（この場合には必ず@code{VAR}）が
@code{yyparse}に返されます。

@c No change is needed in the handling of numeric values and arithmetic
@c operators in @code{yylex}.

@code{yylex}の中で、数値と算術演算子の扱いに関する部分は、
変更する必要がありません。

@smallexample
@group
#include <ctype.h>
yylex ()
@{
  int c;

@c  /* Ignore whitespace, get first nonwhite character.  */
  /* 空白を読み飛ばし、空白以外を得る         */
  while ((c = getchar ()) == ' ' || c == '\t');

  if (c == EOF)
    return 0;
@end group

@group
@c  /* Char starts a number => parse the number.         */
  /* 数値を読む   */
  if (c == '.' || isdigit (c))
    @{
      ungetc (c, stdin);
      scanf ("%lf", &yylval.val);
      return NUM;
    @}
@end group

@group
@c  /* Char starts an identifier => read the name.       */
  /* 識別子を読む */
  if (isalpha (c))
    @{
      symrec *s;
      static char *symbuf = 0;
      static int length = 0;
      int i;
@end group

@group
@c      /* Initially make the buffer long enough
@c         for a 40-character symbol name.  */
      /* バッファの長さの初期値は40文字       */
      if (length == 0)
        length = 40, symbuf = (char *)malloc (length + 1);

      i = 0;
      do
@end group
@group
        @{
@c          /* If buffer is full, make it bigger.        */
          /* あふれたのでバッファを大きくする */
          if (i == length)
            @{
              length *= 2;
              symbuf = (char *)realloc (symbuf, length + 1);
            @}
@c          /* Add this character to the buffer.         */
          /* 文字をバッファに変える           */
          symbuf[i++] = c;
@c          /* Get another character.                    */
          /* 次の文字を読む                   */
          c = getchar ();
        @}
@end group
@group
      while (c != EOF && isalnum (c));

      ungetc (c, stdin);
      symbuf[i] = '\0';
@end group

@group
      s = getsym (symbuf);
      if (s == 0)
        s = putsym (symbuf, VAR);
      yylval.tptr = s;
      return s->type;
    @}

@c  /* Any other character is a token by itself.        */
  /* その他の文字は文字リテラルトークン       */
  return c;
@}
@end group
@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}のようにあらかじめ定義された変数を追加するために
プログラムを変更することは、簡単な仕事でしょう。


@c =====================================================================
@node Exercises,  , Multi-function Calc, Examples
@c @section Exercises
@section 練習問題
@cindex exercises
@cindex 練習問題

@enumerate
@item
@c Add some new functions from @file{math.h} to the initialization list.
@c
@file{math.h}にある関数のいくつかを、初期化リストに追加しなさい。

@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}.
@c
定数の名前と値を記憶する別の配列を追加しなさい。
そして、@code{init_table}を変更し、定数を記号表に追加しなさい。
定数に型@code{VAR}を与えれば簡単でしょう。

@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.
@c
初期化されていない変数について、値を書き込むのではなく、
値を使おうとするとエラーを報告するように、プログラムを改良しなさい。
@end enumerate


@c =====================================================================
@node Grammar File, Interface, Examples, Top
@c @chapter Bison Grammar Files
@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は、文脈自由文法の仕様を入力として受け取り、
その文法の正しいインスタンスを認識する、
C言語の関数を生成します。

@c The Bison grammar input file conventionally has a name ending in @samp{.y}.

Bison文法ファイルの名前は、通常@samp{.y}で終わります。

@menu
* Grammar Outline::   Overall layout of the grammar file.
* Symbols::           Terminal and nonterminal symbols.
* Rules::             How to write grammar rules.
* Recursion::         Writing recursive rules.
* Semantics::         Semantic values and actions.
* Declarations::      All kinds of Bison declarations are described here.
* Multiple Parsers::  Putting more than one Bison parser in one program.
@end menu


@c =====================================================================
@node Grammar Outline, Symbols,  , Grammar File
@c @section Outline of a Bison Grammar
@section Bison文法の概要

@c A Bison grammar file has four main sections, shown here with the
@c appropriate delimiters:

Bison文法ファイルは4つの主要な部分からなります。
それらを、適切な区切り文字とともに示します。

@example
%@{
@c @var{C declarations}
@var{C宣言部（C declarations）}
%@}

@c @var{Bison declarations}
@var{Bison宣言部（Bison declarations）}

%%
@c @var{Grammar rules}
@var{文法規則部（Grammar rules）}
%%

@c @var{Additional C code}
@var{追加のCプログラム部（Additional C code）}
@end example

@c Comments enclosed in @samp{/* @dots{} */} may appear in any of the sections.

@samp{/* @dots{} */}で囲まれたコメントは、どの部分にも書けます。

@menu
* C Declarations::    Syntax and usage of the C declarations section.
* Bison Declarations::  Syntax and usage of the Bison declarations section.
* Grammar Rules::     Syntax and usage of the grammar rules section.
* C Code::            Syntax and usage of the additional C code section.
@end menu


@c =====================================================================
@node C Declarations, Bison Declarations,  , Grammar Outline
@c @subsection The C Declarations Section
@subsection C宣言部
@cindex C declarations section
@cindex declarations, 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）}には、マクロ定義と、文法定義のアクションで
使うための関数と変数の宣言があります。
これらは、@code{yyparse}の定義に優先するように、構文解析器ファイルの最初に
複写されます。
ヘッダファイルから宣言を得るには@samp{#include}を使います。
C宣言がまったく必要ない場合は、この部分を囲む
@samp{%@{}と@samp{%@}}を省略できます。


@c =====================================================================
@node Bison Declarations, Grammar Rules, C Declarations, Grammar Outline
@c @subsection The Bison Declarations Section
@subsection Bison宣言部
@cindex Bison declarations (introduction)
@cindex declarations, Bison (introduction)
@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）}は、終端記号と非終端記号の宣言、
演算子の優先順位の指定などを含みます。
単純な例では、宣言を省略できます。
@xref{Declarations, ,Bison Declarations}。


@c =====================================================================
@node Grammar Rules, C Code, Bison Declarations, Grammar Outline
@c @subsection The Grammar Rules Section
@subsection 文法規則部
@cindex grammar rules section
@cindex rules section for grammar
@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文法規則を含み、
それ以外は含みません。
@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つの文法規則が存在する必要があります。
また、文法規則より先に@samp{%%}が必要で、
もしそれ以前に何も記述されていなくても、省略できません。


@c =====================================================================
@node C Code,  , Grammar Rules, Grammar Outline
@c @subsection The Additional C Code Section
@subsection 追加のCプログラム部
@cindex additional C code section
@cindex C code, section for additional
@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宣言部}が構文解析器ファイルの先頭に複写
されるのと同じように、構文解析器ファイルの末尾にそのまま複写されます。
構文解析器ファイル中に置く必要があって、
@code{yyparse}の定義よりも前に置く必要のないものを、ここに置くと便利です。
たとえば、@code{yylex}と@code{yyerror}の定義は、
よくここに置かれます。
@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{%%}を省略できます。

@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}で始まる多くの静的変数と、
名前が@samp{YY}で始まる多くのマクロを含んでいます。
本書で解説しているものを意図的に使う場合を除いて、
そのような名前を文法ファイルの追加のCプログラム部で使うのは避けるべきです。


@c =====================================================================
@node Symbols, Rules, Grammar Outline, Grammar File
@c @section Symbols, Terminal and Nonterminal
@section 記号、終端と非終端
@cindex nonterminal symbol
@cindex terminal symbol
@cindex token type
@cindex symbol
@cindex 非終端記号
@cindex 終端記号
@cindex トークン型
@cindex 記号

@c @dfn{Symbols} in Bison grammars represent the grammatical classifications
@c of the language.

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{トークン型（tokens types）}ともいいます）は、
構文的に等価なトークンのクラスを表します。
そのクラスのトークンが許されることを表すために、
文法規則の中で記号を使えます。
その記号は、Bison構文解析器の中で番号で表現され、
@code{yylex}関数は、どのような種類のトークンが読み込まれたかを示すために、
トークン番号を返します。
これを表す記号を知っていればよく、その番号を知っている必要はありません。

@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）}は、
構文的に等価なグループを表現します。
記号名は文法規則の記述に使われます。
通常、非終端記号名を小文字で書きます。

@c Symbol names can contain letters, digits (not at the beginning),
@c underscores and periods.  Periods make sense only in nonterminals.

記号名は、英字、先頭以外での数字、下線記号（@samp{_}）とピリオドからなります。
ピリオド記号（@samp{.}）は、非終端記号の名前には使えますが、
終端記号の名前には使えません。

@c There are three ways of writing terminal symbols in the grammar:

文法中で終端記号を記述するには3種類の方法があります。

@itemize @bullet
@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}.
@c 
@dfn{名前付きトークン型（named token type）}を、
C言語における識別子と同様な、識別子とともに書きます。
通常、大文字で書きます。
これらは@code{%token}のようなBison宣言とともに定義する必要があります。
@xref{Token Decl, ,Token Type Names}。

@item
@cindex character token
@cindex literal token
@cindex single-character literal
@cindex 文字トークン
@cindex リテラルトークン
@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}).
@c 
@dfn{文字トークン型（character token type）}、
すなわち@dfn{リテラル文字トークン（literal character token）}は、
C言語の文字定数と同じ構文で書かれ、
たとえば@code{'+'}は文字トークン型です。
意味値データ型（@pxref{Value Type, ,Data Types of Semantic Values}）、
結合性、優先順位（@pxref{Precedence, ,Operator Precedence}）を
指定する必要がなければ、
文字トークン型を宣言する必要はありません。

@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{【訳注】英数字以外の文字。}から
なるトークンを表すためだけに使います。
たとえば、トークン型@code{'+'}を、
トークンとしての@samp{+}文字を表すために使います。
このようにする義務はありませんが、そうしないと、
あなたが書いたプログラムを読む人が混乱するでしょう。

@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言語の文字リテラルで使われる通常のエスケープシーケンス
@footnote{【訳注】@samp{\}に続く表現。}を、Bisonでも使えます。
しかし、@code{'\0'}だけはASCII符号の0を表し、
@code{yylex}がファイルの終わりを示す符号なので、
文字リテラルとしては使えません
（@pxref{Calling Convention, ,Calling Convention for @code{yylex}}）。

@item
@cindex string token
@cindex literal string token
@cindex multi-character literal
@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}).
@c
@dfn{リテラル文字列トークン（literal string token）}は、
C言語における文字列定数と同様に書きます。
たとえば、@code{"<="}がリテラル文字列トークンです。
意味値（@pxref{Value Type}）、
結合性、優先順位（@pxref{Precedence, ,Operator Precedence}）を
指定する必要がなければ、
リテラル文字列トークンを宣言する必要はありません。

@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{yytname}表（@pxref{Calling Convention}）を使って、
リテラル文字列トークンからトークン番号を検索する必要があります。

@c @strong{WARNING}: literal string tokens do not work in 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{<=}を表すために、
トークン型@code{"<="}を使うべきです。
そうする義務はありませんが、そうしないと、
あなたが書いたプログラムを読む人が混乱するでしょう。

@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
C言語で使えるエスケープシーケンスはすべてBisonでも使えます。
リテラル文字列トークンは、2文字以上からなります。
もし、トークンが1文字ならば、前述の1文字トークンを使ってください。
@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}が返す値は、終端記号のどれかを表し、
入力の終わりでは0です。
文法規則の中でどの方法でトークン型を書いても、
@code{yylex}を定義する書き方は同じです。
1文字トークン型に対する符号は、その文字のASCII符号なので、
@code{yylex}は必要な符号を生成するために同一の文字定数を使えます。
名前を付けられたトークン型はそれぞれ、
構文解析器ファイルの中でCのマクロになるので、
@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}が構文解析器と別のソースファイルの中に書かれる場合には、
そこでトークン型マクロ定義を使えるように準備する必要があります。
@samp{-d}オプションを付けてBisonを実行してください。
すると、マクロ定義が@file{@var{name}.tab.h}というファイルに書かれ、
必要に応じて別のソースファイルからインクルードできます。
@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{yylex}がこの値を返すことは決してありません。


@c =====================================================================
@node Rules, Recursion, Symbols, Grammar File
@c @section Syntax of Grammar Rules
@section 文法規則の構文
@cindex rule syntax
@cindex grammar rule syntax
@cindex syntax of grammar rules
@cindex 規則の構文
@cindex 文法規則の構文
@cindex 構文, 文法規則

@c A Bison grammar rule has the following general form:

Bison文法規則は、一般的に次の書式です。

@example
@group
@var{result}: @var{components}@dots{}
        ;
@end group
@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{components}は、この規則で一緒に置かれるさまざまな
終端および非終端記号です。
例を示します。

@example
@group
exp:      exp '+' exp
        ;
@end group
@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{+}トークンを間にはさんで
型@code{exp}の2つのグループ化が行われ、
型@code{exp}のより大きなグループができます。

@c Whitespace in rules is significant only to separate symbols.  You can add
@c extra whitespace as you wish.

規則の中の空白@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{アクション（action）}になることができます。
アクションは、次のようになります。

@example
@{@var{C statements}@}
@end example

@c @noindent
@c Usually there is only one action and it follows the components.
@c @xref{Actions}.

通常、1つだけのアクションと、それに続く@var{components}があります。
@xref{Actions}。

@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}に対する複数の規則は、
別々に書くこともできますし、
次の例のように縦線記号@samp{|}で区切ってまとめて書くことも可能です。

@ifinfo
@example
@var{result}:   @var{rule1-components}@dots{}
        | @var{rule2-components}@dots{}
        @dots{}
        ;
@end example
@end ifinfo
@iftex
@example
@group
@var{result}:    @var{rule1-components}@dots{}
        | @var{rule2-components}@dots{}
        @dots{}
        ;
@end group
@end example
@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{result}が空の列にマッチできることを意味します。
例として、カンマで区切られた0個以上の@code{exp}のグループを
定義する方法を示します。

@example
@group
@c expseq:   /* empty */
expseq:   /* 空 */
        | expseq1
        ;
@end group

@group
expseq1:  exp
        | expseq1 ',' exp
        ;
@end group
@end example

@c @noindent
@c It is customary to write a comment @samp{/* empty */} in each rule
@c with no components.

空の@var{component}を持つ規則には、通常
@samp{/* 空 */}という注釈を書きます。


@c =====================================================================
@node Recursion, Semantics, Rules, Grammar File
@c @section Recursive Rules
@section 再帰的規則
@cindex recursive rule
@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}である非終端記号が規則の右側にも現れる場合に、
その規則は@dfn{再帰的（recursive）}であるといいます。
Bison文法の大部分は再帰的規則を使います。
なぜならば、任意の数の並びを定義する唯一の方法が、
再帰的規則だからです。
1つ以上のカンマで区切られた式の並びの定義を考えてみましょう。

@example
@group
expseq1:  exp
        | expseq1 ',' exp
        ;
@end group
@end example

@cindex left recursion
@cindex right recursion
@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}で使われている再帰は、規則の右側の中でもっとも左側にあるので、
このような再帰を@dfn{左再帰（left recursion）}と呼びます。
逆に、同じ構造を@dfn{右再帰（right recursion）}を使って書いてみます。

@example
@group
expseq1:  exp
        | exp ',' expseq1
        ;
@end group
@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.

あらゆる並びを、左再帰を使っても、右再帰を使っても、定義できます。
しかし、限られたスタック容量で任意の数の並びを走査できるので、
つねに左再帰を使うべきです。
右再帰では、規則が適用される前にすべての要素をスタックに積む必要があるので、
要素の数に比例するスタック領域を消費します。
詳細については、@xref{Algorithm, ,The Bison Parser Algorithm }。

@cindex mutual recursion
@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）}再帰が起きます。

@c For example:

例を示します。

@example
@group
expr:     primary
        | primary '+' primary
        ;
@end group

@group
primary:  constant
        | '(' expr ')'
        ;
@end group
@end example

@c @noindent
@c defines two mutually-recursive nonterminals, since each refers to the
@c other.

この例では、それぞれの規則が互いに参照しているので、
2個の相互再帰が定義されています。


@c =====================================================================
@node Semantics, Declarations, Recursion, Grammar File
@c @section Defining Language Semantics
@section 言語の意味の定義
@cindex defining language semantics
@cindex language semantics, defining 
@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}}}に
対応するアクションが、@var{x}と@var{y}に関する数値の和を計算します。

@menu
* Value Type::        Specifying one data type for all semantic values.
* Multiple Types::    Specifying several alternative data types.
* Actions::           An action is the semantic definition of a grammar rule.
* Action Types::      Specifying data types for actions to operate on.
* Mid-Rule Actions::  Most actions go at the end of a rule.
                      This says when, why and how to use the exceptional
                        action in the middle of a rule.
@end menu


@c =====================================================================
@node Value Type, Multiple Types,  , Semantics
@c @subsection Data Types of Semantic Values
@subsection データ型と意味値
@cindex semantic value type
@cindex value type, semantic
@cindex data types of semantic values
@cindex default data type
@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}）。

@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}型を使います。
他の型を使うには、次の例のように、マクロ@code{YYSTYPE}を定義します。

@example
#define YYSTYPE double
@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宣言部に置く必要があります
（@pxref{Grammar Outline, ,Outline of a Bison Grammar}）。


@c =====================================================================
@node Multiple Types, Actions, Value Type, Semantics
@c @subsection More Than One Value Type
@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{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項目が必要です。

@itemize @bullet
@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}).
@c
Bison宣言の@code{%union}で、考えられるデータ型全体の集合を指定します
（@pxref{Union Decl, ,The Collection of Value Types}）。

@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}).
@c
終端または非終端記号のそれぞれについて、
その意味値を使うために、上記の型のどれか1つを選びます。
トークンに対する型の指定には、Bison宣言の@code{%token}を使います
（@pxref{Token Decl, ,Token Type Names}）。
グループ化に対する型の指定には、Bison宣言の@code{%type}を使います
（@pxref{Type Decl, ,Nonterminal Symbols}）。
@end itemize


@c =====================================================================
@node Actions, Action Types, Multiple Types, Semantics
@c @subsection Actions
@subsection アクション
@cindex action
@cindex アクション
@vindex $$
@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 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の文からなります。
アクションは、規則のどの場所にも置け、その場所で実行されます。
規則のほとんどは、規則の終わりの構成要素の並びの後に、
1つだけアクションを持ちます。
規則の途中に置かれたアクションは、手の込んだ方法で特別な目的に使われます
（@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で書かれたプログラムは、
規則の第@var{n}番目の要素に対応する意味値を、
@code{$@var{n}}という書式で参照できます。
また、その規則が構成するグループの意味値を、
@code{$$}という書式で参照できます。
アクションが構文解析器ファイルに複写されるときに、Bisonは、
上記の構成要素を配列要素への参照に変換します。

@c Here is a typical example:

例を示します。

@example
@group
exp:    @dots{}
        | exp '+' exp
            @{ $$ = $1 + $3; @}
@end group
@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}グループから、
1つの@code{exp}を構成します。
このアクションの中で、@code{$1}と@code{$3}は、
規則の右側の最初と3番目の記号である@code{exp}グループの
意味値を参照します。
この規則によって認識される加算式の値になるように、
和が@code{$$}に代入されます。
もし、@samp{+}トークンに有用な値があるならば、
それを@code{$2}として参照できるでしょう。

@cindex default action
@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は、
省略時アクション@w{@code{$$ = $1}}を補います。
したがって、規則の最初の記号の値が規則全体の値になります。
もちろん、両者の型が一致する場合にのみ、省略時アクションは有効です。
空規則に対する省略時アクションは無意味です。
すべての空規則は、その規則の値が必要ならば、
明示的なアクションを持つ必要があります。

@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または負が許され、
現在の規則にマッチする@emph{前に}スタックに積まれていた
トークンとグループの意味値を参照します。
これは非常に危険な手法で、安全に使うためには、
その規則が適用される文脈をあなたが完全に理解している必要があります。
これを安全に使える例を示します。

@example
@group
foo:      expr bar '+' expr  @{ @dots{} @}
        | expr bar '-' expr  @{ @dots{} @}
        ;
@end group

@group
@c bar:      /* empty */
bar:      /* 空 */
        @{ previous_expr = $0; @}
        ;
@end group
@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{foo}の定義の中で@code{bar}より前の
@code{expr}の値を@code{$0}が参照します。


@c =====================================================================
@node Action Types, Mid-Rule Actions, Actions, Semantics
@c @subsection Data Types of Values in Actions
@subsection アクション中の値のデータ型
@cindex action data types
@cindex data types in actions
@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}}はそのデータ型を持ちます。

@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{$$}と@code{@var{n}}を使うたびに、
規則の中でそれらがどの記号を参照するかに応じて、
データ型が決められます。
例を示します。

@example
@group
exp:    @dots{}
        | exp '+' exp
            @{ $$ = $1 + $3; @}
@end group
@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{$2}が使われるならば、どのような型であれ、
終端記号@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}>}を
挿入します。例を示します。

@example
@group
%union @{
  int itype;
  double dtype;
@}
@end group
@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{int}型として参照でき、@code{$<dtype>1}と書けば、
@code{double}型として参照できます。


@c =====================================================================
@node Mid-Rule Actions,  , Action Types, Semantics
@c @subsection Actions in Mid-Rule
@subsection 規則の途中のアクション
@cindex actions in mid-rule
@cindex mid-rule actions
@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}}を使って参照できますが、後に続く要素は
まだ構文解析されていないので参照できません。

@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つとして数えられます。
同じ規則の中に別のアクションが続く場合（通常は最後）に問題が起きます。
@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{$@var{n}}で値を参照できます。
アクションに記号名を対応させる方法がないので、
アクションのデータ型を宣言できません。
そこで、アクションの意味を参照するときに、
@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{$$}への代入が規則の値に関係しないので、
規則全体の値を設定する方法はありません。
規則全体の値を設定する唯一の方法は、
規則の最後に置かれた通常のアクションです。

@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}}のような書式の
@code{let}文を使え、@var{statement}の持続期間中に一時的に
@var{variable}という名前の変数を作ります。
これを構文解析するために、@var{statement}を解析している間、
@var{variable}を記号表に置いておき、
後で記号表から削除する必要があります。
これを実現する方法を示します。

@example
@group
stmt:   LET '(' var ')'
                @{ $<context>$ = push_context ();
                  declare_variable ($3); @}
        stmt    @{ $$ = $6;
                  pop_context ($<context>5); @}
@end group
@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})}が認識されるとすぐに、
最初のアクションが実行されます。
そのアクションは、現在の意味文脈、すなわち参照可能な変数の表の複製を、
データ型共用体の中の@code{context}型で、
アクションの意味値として保存します。
そして、@code{declare_variable}を呼び出して、
新しい変数を記号表に追加します。
最初のアクションが終わると、後続する@code{stmt}の解析が可能になります。
規則の途中のアクションが5番目の要素であることに注意してください。
したがって、@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}文中での一時変数が表から削除され、
構文解析されるプログラムの残りの部分では一時変数が存在しません。

@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:

構文解析器は、アクションを実行する順序を決めるために、
構文解析する必要があるので、
規則が完全に認識される前にアクションを実行することは、
しばしば不整合を起こします。
たとえば、後述の2個の規則は、規則の途中のアクションを持たないので、
実行可能な構文解析器の中で共存できます。
それは、構文解析器は開きブレーストークンをシフトでき、
宣言があるかどうか調べるために後に続くものを先読みできるからです。

@example
@group
compound: '@{' declarations statements '@}'
        | '@{' statements '@}'
        ;
@end group
@end example

@c @noindent
@c But when we add a mid-rule action as follows, the rules become nonfunctional:
しかし、次の例のように、規則の途中のアクションを加えると、
この規則は働かなくなります。

@example
@group
compound: @{ prepare_for_local_variables (); @}
          '@{' declarations statements '@}'
@end group
@group
        | '@{' statements '@}'
        ;
@end group
@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}.)

ここでは、開きブレースを見つけた時点で、
規則の途中のアクションを実行する必要があるかどうかの決定を迫られます。
言い換えれば、正しく判断するための十分な情報なしに、
ある規則か別の規則のどちらかにゆだねる必要があります。
開きブレーストークンは、これを読んだ時点では構文解析器が
何をすべきか決定する途中なので、@dfn{先読み（look-ahead）}トークンと
呼ばれます。@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:

次のように同一のアクションを置くことで、
この問題を解決できるように思えるかもしれません。

@example
@group
compound: @{ prepare_for_local_variables (); @}
          '@{' declarations statements '@}'
        | @{ prepare_for_local_variables (); @}
          '@{' statements '@}'
        ;
@end group
@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は、アクションの中の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言語のように、最初のトークンによって文と宣言を区別できるような
文法ならば、実現可能な解決方法の1つは、次の例のように、
開きブレースの後にアクションを置くことです。

@example
@group
compound: '@{' @{ prepare_for_local_variables (); @}
          declarations statements '@}'
        | '@{' statements '@}'
        ;
@end group
@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がどちらの規則を使うべきかわかります。

@c Another solution is to bury the action inside a nonterminal symbol which
@c serves as a subroutine:

別の解決方法は、サブルーチンとして働く非終端記号の内側に、
アクションを埋め込むことです。

@example
@group
@c subroutine: /* empty */
subroutine: /* 空 */
          @{ prepare_for_local_variables (); @}
        ;

@end group

@group
compound: subroutine
          '@{' declarations statements '@}'
        | subroutine
          '@{' statements '@}'
        ;
@end group
@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}に対してどちらの規則を使うべきか決めずに、
@code{subroutine}に対する規則中のアクションを実行できます。
任意の規則中のアクションは、この方法によって、
規則の最後のアクションに変換できます。
実際に、Bisonの内部では、このようにして、
規則中のアクションという機能が実現されています。


@c =====================================================================
@node Declarations, Multiple Parsers, Semantics, Grammar File
@c @section Bison Declarations
@section Bison宣言
@cindex declarations, Bison
@cindex Bison declarations
@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）}部では、
文法の定式化に使う記号を定義し、意味値のデータ型を定義します。
@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文字リテラルトークンを除く
すべてのトークンの型名を宣言する必要があります。
非終端記号については、その意味値に対してどのデータ型を使うか
指定したければ、宣言する必要があります
（@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}).

特に指定しないと、文法ファイル中の最初の規則は、
開始記号を特定します。
他の記号を開始記号にしたければ、明示的に宣言する必要があります
（@pxref{Language and Grammar, ,Languages and Context-Free Grammars}）。

@menu
* Token Decl::        Declaring terminal symbols.
* Precedence Decl::   Declaring terminals with precedence and associativity.
* Union Decl::        Declaring the set of all semantic value types.
* Type Decl::         Declaring the choice of type for a nonterminal symbol.
* Expect Decl::       Suppressing warnings about shift/reduce conflicts.
* Start Decl::        Specifying the start symbol.
* Pure Decl::         Requesting a reentrant parser.
* Decl Summary::      Table of all Bison declarations.
@end menu


@c =====================================================================
@node Token Decl, Precedence Decl,  , Declarations
@c @subsection Token Type Names
@subsection トークン型名
@cindex declaring token type names
@cindex token type names, declaring
@cindex declaring literal string tokens
@findex %token
@cindex トークン型名の宣言
@cindex トークン型名, 宣言
@cindex リテラル文字列トークンの宣言

@c The basic way to declare a token type name (terminal symbol) is as follows:

トークン型名、すなわち終端記号を、基本的には次のように宣言します。

@example
%token @var{name}
@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}ディレクティブに変換します。
したがって、関数@code{yylex}が構文解析器ファイルの中にあれば、
そこで名前@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{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。
@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:

トークンの名前の直後に整数値を書くことで、
そのトークン型に対応する数値符号を明示的に指定できます。

@example
%token NUM 300
@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は、トークン型どうしや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}あるいは他のトークン宣言に、
小なり記号と大なり記号で区切った型名を追加する必要があります
（@pxref{Multiple Types, ,More Than One Value Type}）。

@c For example:

例を示します。

@example
@group
@c %union @{              /* define stack type */
%union @{              /* スタックのデータ型を定義する */
  double val;
  symrec *tptr;
@}
@c %token <val> NUM      /* define token NUM and its type */
%token <val> NUM      /* トークン「NUM」とその型を定義する */
@end group
@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}宣言の末尾に
リテラル文字列を書くことで、リテラル文字列トークンと
トークン型名を関連づけできます。

@example
%token arrow "=>"
@end example

@c @noindent
@c For example, a grammar for the C language might specify these names with
@c equivalent literal string tokens:

C言語に対する文法では、次の例のように、
等価なリテラル文字列トークンに名前を指定しています。

@example
%token  <operator>  OR      "||"
%token  <operator>  LE 134  "<="
%left  OR  "<="
@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}関数は、トークン型の数値符号を得るために、
トークン名とリテラル文字列の両方を使えます
（@pxref{Calling Convention}）。


@c =====================================================================
@node Precedence Decl, Union Decl, Token Decl, Declarations
@c @subsection Operator Precedence
@subsection 演算子の優先順位
@cindex precedence declarations
@cindex declaring operator precedence
@cindex operator precedence, declaring
@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}のどれかを使います。
これらは、@dfn{優先順位宣言（precedence declarations）}と呼ばれます。
演算子の優先順位の詳細については、
@xref{Precedence, ,Operator Precedence}。

@c The syntax of a precedence declaration is the same as that of
@c @code{%token}: either

優先順位宣言の構文は、@code{%token}を使う宣言の構文と同じです。

@example
%left @var{symbols}@dots{}
@end example

@c @noindent
@c or

次のようにも書けます。

@example
%left <@var{type}> @var{symbols}@dots{}
@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}を使う宣言が目的とする
すべての機能を持っています。
それに加えて、次のように結合性と、すべての@var{symbols}についての優先順位を指定します。

@itemize @bullet
@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.
@c
演算子@var{op}の結合性は、この演算子が繰り返し使われた場合の
動作を指定します。つまり、@samp{@var{x} @var{op} @var{y} @var{op} @var{z}}が
構文解析された場合に、最初に@var{x}と@var{y}がグループ化されるか、
それとも@var{y}と@var{z}がグループ化されるかを指定します。
@code{%left}は、左結合性、つまり@var{x}と@var{y}が先に結合されることを
指定します。@code{%right}は、右結合性、つまり、
@var{y}と@var{z}が先に結合されることを指定します。
@code{%nonassoc}は、無結合性を指定し、その場合、
@samp{@var{x} @var{op} @var{y} @var{op} @var{z}}は
構文エラーとみなされます。

@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.
@c
演算子の優先順位は、その演算子が他の演算子とともに使われた場合の
動作を指定します。同一の優先順位宣言で宣言されたすべてのトークンは、
同じ優先順位を持ち、その結合性にしたがって処理されます。
2個のトークンが別々の優先順位宣言で宣言されているならば、
文法ファイルの中で後で宣言されたほうの演算子が強い優先順位を持ちます。

@end itemize


@c =====================================================================
@node Union Decl, Type Decl, Precedence Decl, Declarations
@c @subsection The Collection of Value Types
@subsection 値型の集合
@cindex declaring value types
@cindex value types, declaring
@findex %union
@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}に続いて、C言語における共用体の宣言と同様に、
ブレースで囲んだ宣言の並びを書きます。

@c For example:

例を示します。

@example
@group
%union @{
  double val;
  symrec *tptr;
@}
@end group
@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 *}があると、
宣言しています。
それぞれの型には、名前@code{val}と@code{tptr}が与えられています。
これらの名前は、@code{%token}と@code{type}宣言の中で、
終端記号あるいは非終端記号に対する型を選ぶために使えます
（@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言語での共用体宣言とは異なり、閉じブレースの後にセミコロンを
@emph{書いてはいけない}ことに注意してください。


@c =====================================================================
@node Type Decl, Expect Decl, Union Decl, Declarations
@c @subsection Nonterminal Symbols
@subsection 非終端記号
@cindex declaring value types, nonterminals
@cindex value types, nonterminals, declaring
@findex %type
@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{%type}宣言を使います。

@example
%type <@var{type}> @var{nonterminal}@dots{}
@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{type}は@code{%union}で指定した名前の中からあなたが選んだものです
（@pxref{Union Decl, ,The Collection of Value Types}）。
同じ値型を持つ任意の数の非終端記号を、
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}>}が許可されています。


@c =====================================================================
@node Expect Decl, Start Decl, Type Decl, Declarations
@c @subsection Suppressing Conflict Warnings
@subsection 衝突警告の回避
@cindex suppressing conflict warnings
@cindex preventing warnings about conflicts
@cindex warnings, preventing
@cindex conflicts, suppressing warnings of
@findex %expect
@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}）があると、
Bisonは通常警告を表示します。
しかし、実際の文法のほとんどは、無害なシフト還元衝突を含み、
その衝突は、予測可能な方法で回避できますが、除去は困難です。
衝突の数が変わらないかぎり、このような衝突の警告は
抑制させるべきです。
そのために、@code{%expect}宣言を使います。

@c The declaration looks like this:

次のように宣言します。

@example
%expect @var{n}
@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}個のシフト還元衝突があって、
還元/還元衝突がなければ、警告が表示されません。
シフト還元衝突の数が@var{n}でなかったり、
1つでも還元/還元衝突があった場合は、通常の警告が表示されます。

@c In general, using @code{%expect} involves these steps:

一般に、次のような手順で@code{%expect}を使います。

@itemize @bullet
@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.
@c
@code{%expect}なしで文法ファイルをコンパイルします。
衝突が起こる位置の詳細な目録を得るために、@samp{-v}オプションを指定します。
Bisonは、衝突の数も表示します。

@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.
@c
衝突のそれぞれについて、Bisonの省略時の解決方法が、
あなたの望みどおりであるか、確かめます。
もし不都合があれば、文法ファイルを書き直して、最初に戻ります。

@item
@c Add an @code{%expect} declaration, copying the number @var{n} from the
@c number which Bison printed.
@c
Bisonが表示した衝突の数@var{n}を書き写して、
@code{%expect}宣言を追加します。

@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はチェックした衝突について文句をいわなくなりますが、
文法ファイルを書き換えて衝突の数が変わると、
再び警告を表示します。


@c =====================================================================
@node Start Decl, Pure Decl, Expect Decl, Declarations
@c @subsection The Start-Symbol
@subsection 開始記号
@cindex declaring the start symbol
@cindex start symbol, declaring
@cindex default start symbol
@findex %start
@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は、文法定義部にある最初の非終端記号を、
省略時の開始記号と仮定します。
次のような@code{%start}宣言で、明示的に開始記号を指定できます。

@example
%start @var{symbol}
@end example


@c =====================================================================
@node Pure Decl, Decl Summary, Start Decl, Declarations
@c @subsection A Pure (Reentrant) Parser
@subsection 純粋（再入可能）構文解析器
@cindex reentrant parser
@cindex pure parser
@findex %pure_parser
@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{純粋な（pure）}（読み出し専用）コードからなる
プログラムです。
@footnote{【訳注】ある手続きの終了を待たずに、その手続きを再度呼び出せる
ことでもあります。}
再入可能性は、非同期実行が可能な場合に重要です。
たとえば、再入可能でないプログラムを、
シグナルハンドラから呼び出すことは危険です。マルチスレッド制御システムでは、
再入不能プログラムはインターロックからしか呼び出せません。

@c The Bison parser is not normally a reentrant program, because it uses
@c statically allocated variables for communication with @code{yylex}.  These
@c variables include @code{yylval} and @code{yylloc}.

通常のBison構文解析器は、@code{yylex}と通信するために静的
@footnote{【訳注】他のソースファイルから見えないとう意味ではなく、
メモリ上の固定番地に置かれるという意味。}変数を使うので、
再入可能プログラムでありません。これらの変数には、
@code{yylval}と@code{yyloc}が含まれます。

@c The Bison declaration @code{%pure_parser} says that you want the parser
@c to be reentrant.  It looks like this:

次のような@code{%pure_parser} Bison宣言は、
再入可能な構文解析器を生成します。

@example
%pure_parser
@end example

@c The effect is that the two communication variables become local
@c variables in @code{yyparse}, and a different calling convention is used
@c for the lexical analyzer function @code{yylex}.  @xref{Pure Calling,
@c ,Calling Conventions for Pure Parsers}, for the details of this.  The
@c variable @code{yynerrs} also becomes local in @code{yyparse}
@c (@pxref{Error Reporting, ,The Error Reporting Function @code{yyerror}}).
@c The convention for calling @code{yyparse} itself is unchanged.

この宣言によって、上記の2個の通信用変数が、@code{yyparse}の局所変数になり、
@code{yylex}字句解析関数を呼び出す方法が変わります。
詳細については、@xref{Pure Calling, ,Calling Conventions for Pure Parsers}。
@code{yyparse}の中の@code{yynerrs}変数も局所変数になります
（@pxref{Error Reporting, ,The Error Reporting Function @code{yyerror}}）。
@code{yypase}関数自体を呼び出す方法は変わりません。


@c =====================================================================
@node Decl Summary,  , Pure Decl, Declarations
@c @subsection Bison Declaration Summary
@subsection Bison宣言の要約
@cindex Bison declaration summary
@cindex declaration summary
@cindex summary, Bison declaration
@cindex Bison宣言の要約
@cindex 宣言の要約
@cindex 要約, Bison宣言

@c Here is a summary of all Bison declarations:

Bison宣言の要約を示します。

@table @code
@item %union
@c Declare the collection of data types that semantic values may have
@c (@pxref{Union Decl, ,The Collection of Value Types}).
@c
意味値が持ちうるデータ型の集合を宣言します
（@pxref{Union Decl, ,The Collection of Value Types}）。

@item %token
@c Declare a terminal symbol (token type name) with no precedence
@c or associativity specified (@pxref{Token Decl, ,Token Type Names}).
@c
優先順位と結合性を指定せずに、終端記号（トークン型名）を宣言します
（@pxref{Token Decl, ,Token Type Names}）。

@item %right
@c Declare a terminal symbol (token type name) that is right-associative
@c (@pxref{Precedence Decl, ,Operator Precedence}).
@c
右結合的な終端記号（トークン型名）を宣言します
（@pxref{Precedence Decl, ,Operator Precedence}）。

@item %left
@c Declare a terminal symbol (token type name) that is left-associative
@c (@pxref{Precedence Decl, ,Operator Precedence}).
@c
左結合的な終端記号（トークン型名）を宣言します
（@pxref{Precedence Decl, ,Operator Precedence}）。

@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}）。

@item %type
@c Declare the type of semantic values for a nonterminal symbol
@c (@pxref{Type Decl, ,Nonterminal Symbols}).
@c
非終端記号に対する意味値の型を宣言します
（@pxref{Type Decl, ,Nonterminal Symbols}）。

@item %start
@c Specify the grammar's start symbol (@pxref{Start Decl, ,The Start-Symbol}).
@c
文法の開始記号を宣言します
（@pxref{Start Decl, ,The Start-Symbol}）。

@item %expect
@c Declare the expected number of shift-reduce conflicts
@c (@pxref{Expect Decl, ,Suppressing Conflict Warnings}).
@c
予想されるシフト還元衝突の数を宣言します
（@pxref{Expect Decl, ,Suppressing Conflict Warnings}）。

@item %pure_parser
@c Request a pure (reentrant) parser program
@c (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).
@c
純粋な（再入可能な）構文解析器を生成します
（@pxref{Pure Decl, ,A Pure (Reentrant) Parser}）。

@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.
@c
構文解析器ファイルに、@code{#line}プリプロセッサディレクティブを生成しません。
Bisonは、通常、Cコンパイラとデバッガがエラーとあなたのソースファイル
（文法ファイル）を関連づけられるように、構文解析器ファイルに
@code{#line}ディレクティブを書き込みます。
@code{%no_lines}宣言は、エラーを構文解析器ファイルの行数と関連づけ、
構文解析器ファイルをそれ自身で独立したソースファイルと
みなすことを意味します。

@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.)
@c
通常、出力ファイル@file{@var{name}.h}は、
Yacc互換トークン番号を定義します。
このオプションが指定されると、代わりに、Bison内部の番号が使われます
（Yacc互換番号は、1文字リテラルトークンを除いて、257から始まりますが、
Bison内部のトークン番号は常に3から始まる連番になります）。

@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.
@c 
構文解析器ファイルの中に、トークン名の表を生成します。
その表の名前は@code{yytname}で、@code{yytname[@var{i}]}が
Bison内部トークン番号@var{i}のトークンの名前です。
最初の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文字リテラルトークンにはシングルクォート記号が、
文字列リテラルトークンにはダブルクォート記号が含まれます。
たとえば、@code{"'+'"}は1文字リテラルトークンで、
@code{"\"<=\""}は文字列リテラルトークンです。
文字列リテラルトークンのすべての文字はそのまま表に現れ、
ダブルクォート記号もエスケープされません。
たとえば、トークンが3文字@samp{*"*}からなれば、
@code{yytname}中の文字列は@samp{"*"*"}となります
（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}:
@c
@code{%token_table}を指定すると、Bisonは、マクロ
@code{YYNTOKENS}、@code{YYNNTS}、@code{YYNRULES}、@code{YYNSTATES}の
定義も生成します。

@table @code
@item YYNTOKENS
@c The highest token number, plus one.
@c
最大のトークン番号＋1。
@item YYNNTS
@c The number of non-terminal symbols.
非終端記号の数。
@item YYNRULES
@c The number of grammar rules,
文法規則の数。
@item YYNSTATES
@c The number of parser states (@pxref{Parser States}).
構文解析器の状態の数（@pxref{Parser States}）。
@end table
@end table


@c =====================================================================
@node Multiple Parsers,, Declarations, Grammar File
@c @section Multiple Parsers in the Same Program
@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つだけ含みます。
しかし、1つのプログラムで2種類以上の言語を構文解析したいときは、
どうすればよいでしょうか？　そうするためには、@code{yyparse}、@code{yylval}
などの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}}の利用です
（@pxref{Invocation, ,Invoking Bison}）。
これによって、Bison構文解析器のインターフェイス関数と変数の名前が、
@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{yylval}、@code{yychar}、@code{yydebug}で全部です。
たとえば、@samp{-p c}オプションを使えば、これらの名前は、
@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に関連する上記以外の変数とマクロのすべての
名前は変わりません。}これらは、広域ではないので、
異なる構文解析器で同じ名前が使われても衝突しません。
たとえば、@code{YYSTYPE}の名前は変わりませんが、
この定義は構文解析器ごとに異なる方法で行われるので、問題ありません
（@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}オプションは、さらに、構文解析器ソースファイルの始めで、
@code{yyparse}を@code{@var{prefix}parse}と定義するように、
マクロを定義します。
この結果、構文解析器ソースファイル全体で、ある名前を別の名前に変えます。


@c =====================================================================
@node Interface, Algorithm, Grammar File, Top
@c @chapter Parser C-Language Interface
@chapter 構文解析器のC言語インターフェイス
@cindex C-language interface
@cindex interface
@cindex C言語インターフェイス
@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の関数です。
ここでは、@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の識別子が
使われていることに注意してください。
本書で説明しているものを除いて、そのような識別子を
文法ファイルのアクションや追加のCプログラムの中で使うと、
問題が起きるでしょう。

@menu
* Parser Function::   How to call @code{yyparse} and what it returns.
* Lexical::           You must supply a function @code{yylex} 
                        which reads tokens.
* Error Reporting::   You must supply a function @code{yyerror}.
* Action Features::   Special features for use in actions.
@end menu


@c =====================================================================
@node Parser Function, Lexical,  , Interface
@c @section The Parser Function @code{yyparse}
@section 構文解析器関数@code{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}関数から戻るような
アクションを書くことも可能です。

@c The value returned by @code{yyparse} is 0 if parsing was successful (return
@c is due to end-of-input).

構文解析が成功する、つまり入力ファイルの終わりに達すると、
@code{yyparse}からの戻り値が0になります。

@c The value is 1 if parsing failed (return is due to a syntax error).

構文解析が失敗する、つまり構文エラーが発生すると、
戻り値が1になります。

@c In an action, you can cause immediate return from @code{yyparse} by using
@c these macros:

アクションの中で、次のマクロを使って、
@code{yyparse}からただちに戻れます。

@table @code
@item YYACCEPT
@findex YYACCEPT
@c Return immediately with value 0 (to report success).
成功の印である戻り値0をともなって、ただちに戻ります。

@item YYABORT
@findex YYABORT
@c Return immediately with value 1 (to report failure).
失敗の印である戻り値1をともなって、ただちに戻ります。

@end table


@c =====================================================================
@node Lexical, Error Reporting, Parser Function, Interface
@c @section The Lexical Analyzer Function @code{yylex}
@section 字句解析器関数@code{yylex}
@findex yylex
@cindex lexical analyzer
@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}は、
入力からトークンを認識し、構文解析器に返します。
Bisonはこの関数を自動的に生成しないので、
@code{yyparse}から呼び出されるように@code{yylex}を書く必要があります。
関数@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}が別のソースファイルの中で定義する場合は、
そこでトークン型マクロ定義を使えるように準備する必要があります。
そのためには、@samp{-d}オプションを指定してBisonを実行してください。
すると、マクロ定義がヘッダファイル@file{@var{name}.tab.h}に
書き込まれ、それを必要とするソースファイルにインクルードできます。
@xref{Invocation, ,Invoking Bison}。

@menu
* Calling Convention::  How @code{yyparse} calls @code{yylex}.
* Token Values::      How @code{yylex} must return the semantic value
                        of the token it has read.
* Token Positions::   How @code{yylex} must return the text position
                        (line number, etc.) of the token, if the
                        actions want that.
* Pure Calling::      How the calling convention differs
                        in a pure parser (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).
@end menu


@c =====================================================================
@node Calling Convention, Token Values,  , Lexical
@c @subsection Calling Convention for @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}が返す値は、見つかったトークンの型に対する番号で、
入力ファイルの終わりに達した場合には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のマクロとして定義されます。
したがって、@code{yylex}は型を示すためにその名前を使用できます。
@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文字リテラルとして参照される場合には、
その文字の文字符号がトークン型に対する番号でもあります。
そこで、@code{yylex}は、単純に文字符号を返します。
しかし、戻り値0は入力ファイルの終わりを意味するので、
ヌル文字（@code{'\0'}）の文字符号を返してはいけません。

@c Here is an example showing these things:

以下に例を示します。

@example
yylex ()
@{
  @dots{}
@c   if (c == EOF)     /* Detect end of file. */
  if (c == EOF)     /* ファイルの終わりか調べる。 */
    return 0;
  @dots{}
  if (c == '+' || c == '-')
@c     return c;      /* Assume token type for `+' is '+'. */
    return c;      /* `+' に対するトークン型が '+' であると仮定する。 */
  @dots{}
@c   return INT;      /* Return the type of the token. */
  return INT;      /* トークン型を返す。 */
  @dots{}
@}
@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{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}がそれに対するトークン型番号を使う、
2つの方法があります。

@itemize @bullet
@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}.
@c
文法が文字列リテラルトークンに対する別名として記号トークン名を
定義しているならば、@code{yylex}はその記号名を他のトークンの記号名と
同様に使えます。この場合、文法ファイルの中での文字列リテラルトークンの
利用は、@code{yylex}にまったく影響しません。

@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.
@c
@code{yylex}は、@code{yytname}表の中で、
複数文字トークンを見つけられます。
トークンに対する表の添え字は、そのトークン型の番号です。
複数文字トークンは@code{yytname}の中にダブルクォート記号で囲まれて
記憶されます。
トークンに含まれる文字はエスケープされず、
表の中の文字列にそのまま書き込まれています。

@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{yytname}からトークンを探し出すプログラムを示します。

@smallexample
for (i = 0; i < YYNTOKENS; i++)
  @{
    if (yytname[i] != 0
        && yytname[i][0] == '"'
        && strncmp (yytname[i] + 1, token_buffer, strlen (token_buffer))
        && yytname[i][strlen (token_buffer) + 1] == '"'
        && yytname[i][strlen (token_buffer) + 2] == 0)
      break;
  @}
@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}宣言をした場合にのみ生成されます。
@xref{Decl Summary}。

@end itemize


@c =====================================================================
@node Token Values, Token Positions, Calling Convention, Lexical
@c @subsection Semantic Values of Tokens
@subsection トークンの意味値

@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}に代入される必要があります。
意味値に対してただ1つのデータ型を使っている場合には、
@code{yylval}の型もそうです。
したがって、たとえば、宣言を省略して型が@code{int}ならば、
次のように書けます。

@example
@group
  @dots{}
@c   yylval = value;  /* Put value onto Bison stack. */
  yylval = value;  /* 値をBisonスタックに積む。 */
@c   return INT;      /* Return the type of the token. */
  return INT;      /* トークン型を返す。 */
  @dots{}
@end group
@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}の型になります
（@pxref{Union Decl, ,The Collection of Value Types}）。
そこで、トークンの値を代入するには、
共用体のメンバの名前を指定する必要があります。
@code{%union}宣言の例を示します。

@example
@group
%union @{
  int intval;
  double val;
  symrec *tptr;
@}
@end group
@end example

@c @noindent
@c then the code in @code{yylex} might look like this:

すると、@code{yylex}の中のプログラムは次のようになります。

@example
@group
  @dots{}
@c   yylval.intval = value; /* Put value onto Bison stack. */
  yylval.intval = value; /* 値をBisonスタックに積む。 */
@c   return INT;          /* Return the type of the token. */
  return INT;          /* トークン型を返す。 */
  @dots{}
@end group
@end example


@c =====================================================================
@node Token Positions, Pure Calling, Token Values, Lexical
@c @subsection Textual Positions of Tokens
@subsection トークンのテキスト中の位置

@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}}機能
（@pxref{Action Features, ,Special Features for Use in Actions}）を
使っている場合には、トークンとグループのテキスト中の位置を
見失わないように、@code{yylex}の中で位置情報を提供する必要があります。
関数@code{yyparse}は、ちょうど解析されたトークンのテキスト中の位置が、
広域変数@code{yylloc}に記憶されていると仮定します。
そこで、@code{yylex}は、@code{yyloc}に正しいデータを記憶する必要があります。
変数@code{yylloc}は構造体で、アクションの中で使われる場合にのみ、
メンバを初期化する必要があります。
メンバは、@code{first_line}、@code{first_column}、
@code{last_line}、@code{last_column}の4つです。
この機能を使うと、構文解析器が著しく遅くなることに注意してください。

@tindex YYLTYPE
@c The data type of @code{yylloc} has the name @code{YYLTYPE}.

@code{yylloc}のデータ型は、@code{YYLTYPE}という名前を持っています。


@c =====================================================================
@node Pure Calling,  , Token Positions, Lexical
@c @subsection Calling Conventions for Pure Parsers
@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{yylloc}を使えなくなります
（@pxref{Pure Decl, ,A Pure (Reentrant) Parser}）。
このような構文解析器では、2つの広域変数の代わりに、
@code{yylex}への引数として渡されるポインタを使います。
@code{yylex}を次のように宣言し、
これらのポインタを通して情報を受け渡しする必要があります。

@example
yylex (lvalp, llocp)
     YYSTYPE *lvalp;
     YYLTYPE *llocp;
@{
  @dots{}
@c   *lvalp = value;  /* Put value onto Bison stack.  */
  *lvalp = value;  /* 値をBisonスタックに積む。  */
@c   return INT;      /* Return the type of the token.  */
  return INT;      /* トークン型を返す。 */
  @dots{}
@}
@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{@@}機能を
使っていない場合は、@code{YYLTYPE}は定義されません。
この場合、第2引数を省略し、@code{yylex}は
1個の引数をともなって呼び出されます。

@vindex YYPARSE_PARAM
@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}は、定義された名前で、型が@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{void *}型にキャストして渡します。
文法のアクションは、ポインタを適切な型へのポインタへキャストし、
逆参照して、オブジェクトの内容を参照できます。
例を示します。

@example
%@{
struct parser_control
@{
  int nastiness;
  int randomness;
@};

#define YYPARSE_PARAM parm
%@}
@end example

@c @noindent
@c Then call the parser like this:
次のように構文解析器を呼び出します。

@example
struct parser_control
@{
  int nastiness;
  int randomness;
@};

@dots{}

@{
  struct parser_control foo;
@c  @dots{}  /* @r{Store proper data in @code{foo}.}  */
  @dots{}  /* @r{@code{foo}に正しいデータを記憶}  */
  value = yyparse ((void *) &foo);
  @dots{}
@}
@end example

@c @noindent
@c In the grammar actions, use expressions like this to refer to the data:

文法アクションの中では、データを参照するために次のような式を使います。

@example
((struct parser_control *) parm)->randomness
@end example

@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{YYPARSE_PARAM}と同様に、マクロ@code{YYLEX_PARAM}を定義します。
例を示します。

@example
%@{
struct parser_control
@{
  int nastiness;
  int randomness;
@};

#define YYPARSE_PARAM parm
#define YYLEX_PARAM parm
%@}
@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{YYLTYPE}のどの引数が渡されるかに応じて、
引数の合計が2個または3個になります）。
引数を正しいオブジェクト型として宣言できます。すなわち@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}を呼び出すべきです。


@c =====================================================================
@node Error Reporting, Action Features, Lexical, Interface
@c @section The Error Reporting Function @code{yyerror}
@section エラー報告関数@code{yyerror}
@cindex error reporting function
@findex yyerror
@cindex parse error
@cindex syntax error
@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構文解析器は、文法規則に適合しないトークンを読むたびに、
@dfn{構文解析エラー（parse error）}すなわち@dfn{文法エラー（syntax error）}を
検出します。文法中のアクションは、マクロ@code{YYERROR}を使って、
明示的にエラーを示せます
（@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}という名前の関数を使って、
エラーを報告するようになっています。
事前に用意が必要な
この関数は、文法エラーが発生するたびに、1個の引数をともなって、
@code{yyparse}から呼び出されます。
構文解析エラーに対して、引数の文字列は通常@w{@code{"parse error"}}です。

@findex YYERROR_VERBOSE
@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}）で、
マクロ@code{YYERROR_VERBOSE}を定義すると、
@w{@code{"parse error"}}の代わりに、
エラーを詳細に報告する文字列が用意されます。
マクロ@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種類のエラーであるスタックオーバーフローを検出する
可能性があります。これは、入力がきわめて深い入れ子からなっていると
起こることがあります。Bison構文解析器は自動的にスタックの限界を大きく拡張し
ているので、スタックオーバーフローはめったに起きません。
しかし、もしスタックオーバーフローが起きれば、
@w{@code{"parser stack overflow"}}という
文字列の引数をともなって、@code{yyerror}が呼び出されます。

@c The following definition suffices in simple programs:

単純なプログラムでは、次の例のように@code{yyerror}を定義できます。

@example
@group
yyerror (s)
     char *s;
@{
@end group
@group
  fprintf (stderr, "%s\n", s);
@}
@end group
@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}は、
適切なエラー回復文法規則（@pxref{Error Recovery}）があれば、
エラーからの回復を試みます。
もし、回復が不可能ならば、@code{yyparse}は即座に1を返します。

@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}には、それまでに出くわした文法エラーの数が記憶されています。
通常、この変数は広域変数です。
しかし、再入可能な構文解析器（@pxref{Pure Decl, ,A Pure (Reentrant) Parser}）
を生成した場合には、アクションからのみ参照可能な局所変数になります。


@c =====================================================================
@node Action Features,  , Error Reporting, Interface
@c @section Special Features for Use in Actions
@section アクション中で使える特別な機能
@cindex summary, action features
@cindex action fetures summary
@cindex 要約, アクション
@cindex アクションの要約
 
@c Here is a table of Bison constructs, variables and macros that
@c are useful in actions.

ここの表では、アクション中で有用な、Bisonの構造物、変数、
マクロを示します。

@table @samp
@item $$
@c Acts like a variable that contains the semantic value for the
@c grouping made by the current rule.  @xref{Actions}.
@c
現在の規則で作られるグループに対する意味値を保持する変数のように働きます。
@xref{Actions}。

@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}.
@c
現在の規則の@var{n}番目の構成要素に対する意味値を保持する変数のように
働きます。@xref{Actions}。

@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}.
@c
@code{$$}に似ていますが、@code{%union}宣言で指定された共用体の中の
@var{typealt}を選びます。
@xref{Action Types, ,Data Types of Values in Actions}。

@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
@c
@code{$@var{n}}に似ていますが、@code{%union}宣言で指定された共用体の中の
@var{typealt}を選びます。
@xref{Action Types, ,Data Types of Values in Actions}。

@item YYABORT;
@c Return immediately from @code{yyparse}, indicating failure.
@c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
@c
@code{yyparse}からただちに戻り、失敗を示します。
@xref{Parser Function, ,The Parser Function @code{yyparse}}。

@item YYACCEPT;
@c Return immediately from @code{yyparse}, indicating success.
@c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
@c
@code{yyparse}からただちに戻り、成功を示します。
@xref{Parser Function, ,The Parser Function @code{yyparse}}。

@item YYBACKUP (@var{token}, @var{value});
@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.
@c
トークンを逆シフトします。
1個の値を還元する規則の中で、先読みトークンがない場合にのみ、
このマクロが使えます。
このマクロは、トークン型が@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}をともなう
文法エラーが報告され、通常のエラー回復が行われます。

@c In either case, the rest of the action is not executed.

どちらの場合も、アクションの残りの部分は実行されません。

@item YYEMPTY
@vindex YYEMPTY
@c Value stored in @code{yychar} when there is no look-ahead token.
@c
先読みトークンがない場合に、変数@code{yychar}に記憶されている値です。

@item 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}.
@c
ただちに文法エラーを発生させます。この文は、構文解析器がエラーを検出したように
エラー回復を始めますが、@code{yyerror}を呼び出さず、
メッセージは表示されません。
もし、エラーメッセージを表示したければ、@samp{YYERROR}文よりも先に、
明示的に@code{yyerror}を呼び出してください。
@xref{Error Recovery}。

@item YYRECOVERING
@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}.
@c
このマクロの値は、字句解析器が文法エラーからの回復中ならば1、
そうでなければ0です。
@xref{Error Recovery}。

@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}.
@c
現在の先読みトークンを含んでいる変数です
（再入可能構文解析器では、@code{yyparse}の局所変数です）。
先読みトークンがない場合には、この変数に
@code{YYEMPTY}という値が入っています。
@xref{Look-Ahead, ,Look-Ahead Tokens}。

@item yyclearin;
@c Discard the current look-ahead token.  This is useful primarily in
@c error rules.  @xref{Error Recovery}.
@c
現在の先読みトークンを捨てます。エラー規則の中で有用です。
@xref{Error Recovery}。

@item yyerrok;
@c Resume generating error messages immediately for subsequent syntax
@c errors.  This is useful primarily in error rules.  
@c @xref{Error Recovery}.
@c
後に続く文法エラーに対して、エラーメッセージの生成を再開します。
これは、エラー規則で特に重要です。
@xref{Error Recovery}。

@item @@@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:
@c
現在の規則の第@var{n}要素の、行番号と列番号を含む、
配列変数のように働きます。
次のようなメンバがあります。

@example
struct @{
  int first_line, last_line;
  int first_column, last_column;
@};
@end example

@c Thus, to get the starting line number of the third component, use
@c @samp{@@3.first_line}.

たとえば、第3要素の開始行番号を知るには、
@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}はそのメンバの値を設定するだけでかまいません。
@footnote{【訳注】@code{yylex}は、変数@code{yylloc}に、
トークンの位置情報を代入します。}

@c The use of this feature makes the parser noticeably slower.

この機能を使うと、字句解析器が著しく遅くなります。
@end table


@c =====================================================================
@node Algorithm, Error Recovery, Interface, Top
@c @chapter The Bison Parser Algorithm 
@chapter Bison構文解析器のアルゴリズム
@cindex Bison parser algorithm 
@cindex algorithm of parser
@cindex shifting
@cindex reduction
@cindex parser stack
@cindex stack, parser
@cindex Bison構文解析器のアルゴリズム
@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構文解析器は、トークンを読むと、トークンの意味値とともにスタックに積みます。
このスタックを@dfn{構文解析器スタック（parser stack）}と呼びます。
トークンをスタックに積むことを、伝統的に
@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{3}を受け取ったと仮定します。
スタックには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}個のトークンとグループが文法規則に当てはまる場合には、
それらは規則に従って組み合わされます。
これを、@dfn{還元（reduction）}と呼びます。
スタックにあったトークンとグループは、
規則の結果、つまり左側にある記号である、1個のグループに置き換えられます。
規則のアクションの実行は、結果のグループの意味値を計算するので、
還元の手順の1つです。

@c For example, if the infix calculator's parser stack contains this:

たとえば、中間記法電卓の構文解析器スタックの内容は次のようになります。

@example
1 + 5 * 3
@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に還元されます。

@example
expr: expr '*' expr;
@end example

@c @noindent
@c Then the stack contains just these three elements:

そして、スタックは3個の要素を持ちます。

@example
1 + 15
@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を得ます。
そして、改行符号がシフトされます。

@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個のグループに還元しようとします
（@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
* Look-Ahead::        Parser looks one token ahead when deciding what to do.
* Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
* Precedence::        Operator precedence works by resolving conflicts.
* Contextual Precedence::  When an operator's precedence depends on context.
* Parser States::     The parser is a finite-state-machine with stack.
* Reduce/Reduce::     When two rules are applicable in the same situation.
* Mystery Conflicts::  Reduce/reduce conflicts that look unjustified.
* Stack Overflow::    What happens when stack gets full.  How to avoid it.
@end menu


@c =====================================================================
@node Look-Ahead, Shift/Reduce,  , Algorithm
@c @section Look-Ahead Tokens
@section 先読みトークン
@cindex look-ahead token
@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}個のトークン
またはグループが見つかるとすぐに還元を行う@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）}になり、
スタックには置かれません。
先読みトークンを残したまま、構文解析器が、スタック上のトークンまたは
グループに対して1個以上の還元を実行します。
それ以上の還元が起こりえない場合に、
先読みトークンはスタックにシフトされます。
これは、すべての可能な還元が実行されたことを意味しません。
先読みトークンのトークン型に応じて、
いくつかの規則は適用を遅らされているかもしれません。

@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{!}）、
グループのためのかっこを含みます。

@example
@group
expr:     term '+' expr
        | term
        ;
@end group

@group
term:     '(' expr ')'
        | term '!'
        | NUMBER
        ;
@end group
@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}}が読み込まれてシフトされているときに、
何が起きるでしょうか。もし、続くトークンが@samp{)}ならば、
最初の3個のトークンは@code{expr}の形式に還元される必要があります。
これが、唯一有効な道です。
なぜならば、@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{!}ならば、それはただちにシフトされる必要があり、
@w{@samp{2 !}}から@code{term}が還元されます。
そうではなく、構文解析器がシフトの前に還元していれば、
@w{@samp{1 + 2}}が@code{expr}に還元されます。
しかし、そのような還元をしようとすると@code{expr '!'}という記号列を
スタックに生成しようとするので、@samp{!}をシフトするのは不可能です。
そのような記号列は許されません。

@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}に記憶されています
@xref{Action Features, ,Special Features for Use in Actions}。


@c =====================================================================
@node Shift/Reduce, Precedence, Look-Ahead, Algorithm
@c @section Shift/Reduce Conflicts
@section シフト還元衝突
@cindex conflicts
@cindex shift/reduce conflicts
@cindex dangling else
@cindex else, dangling
@cindex 衝突
@cindex シフト還元衝突
@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''文を持つ
言語の構文解析について考えます。

@example
@group
if_stmt:
          IF expr THEN stmt
        | IF expr THEN stmt ELSE stmt
        ;
@end group
@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}は、
キーワードトークンを表す終端記号であると仮定します。

@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}トークンが読まれて先読みトークンになったときに、
入力が正しいと仮定して、スタックの内容はちょうど
最初の規則で還元される右辺になっています。
しかし、いずれ起こるはずの第2の規則の還元のために、
@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）}と呼びます。
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}のシフトを選ぶので、その結果、
else節はもっとも内側のif文に対応し、次の2つの入力は等価になります。

@example
if x then if y then win (); else lose;

if x then do; if y then win (); else lose; end;
@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つの入力は等価になります。

@example
if x then if y then win (); else lose;

if x then do; if y then win (); end; else lose;
@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文について、どちらの構文解析結果も正当なのです。
確立された習慣では、else節をもっとも内側のif文に対応させて、
あいまいさを解決しています。
これが、Bisonが還元よりもシフトを選ぶ理由です
（理想的には、あいまいでない文法を書くべきですが、この場合には困難です）。
この問題は、Algol 60の仕様の中に現れたのが最初で、
「ぶらさがり@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が警告を表示しないように、
@code{%expect @var{n}}宣言を使えます。
すると、ちょうど@var{n}個のシフト還元衝突があるかぎり、
警告は表示されません。
@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}の定義は、衝突をわざと発生させるために書きましたが、
追加の規則がなければ実際には衝突が起きません。
次に、実際に衝突を含む完全なBison入力ファイルの例を示します。

@example
@group
%token IF THEN ELSE variable
%%
@end group
@group
stmt:     expr
        | if_stmt
        ;
@end group

@group
if_stmt:
          IF expr THEN stmt
        | IF expr THEN stmt ELSE stmt
        ;
@end group

expr:     variable
        ;
@end example


@c =====================================================================
@node Precedence, Contextual Precedence, Shift/Reduce, Algorithm
@c @section Operator Precedence
@section 演算子の優先順位
@cindex operator precedence
@cindex precedence of operators
@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.

シフト還元衝突が起きる別の可能性は、算術式の中にあります。
この場合には、シフトの選択が望ましい解決策であるとは限りません。
どのような場合にシフトしてどのような場合に還元するべきか指定するために、
演算子の優先順位についてのBison宣言を使えます。

@menu
* Why Precedence::    An example showing why precedence is needed.
* Using Precedence::  How to specify precedence in Bison grammars.
* Precedence Examples::  How these features are used in the previous example.
* How Precedence::    How they work.
@end menu


@c =====================================================================
@node Why Precedence, Using Precedence,  , Precedence
@c @subsection When Precedence is Needed
@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通りに構文解析されうるので、
この文法はあいまいです。

@example
@group
expr:     expr '-' expr
        | expr '*' expr
        | expr '<' expr
        | '(' expr ')'
        @dots{}
        ;
@end group
@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{)}ならば、還元する必要があります。
なぜならば、もしシフトすると、@w{@samp{- 2 )}}またはそれで始まる
記号列を還元する必要が生じ、そのような規則はないからです。
しかし、次のトークンが@samp{*}または@samp{<}ならば、
シフトと還元のどちらも可能です。
どちらを選んでも構文解析を完了できますが、解析の結果は異なります。

@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字句解析器がどちらの処理をすべきか決めるために、
構文解析の結果を考慮する必要があります。
もし、次の演算子トークン@var{op}がシフトされるならば、
還元して差を求める可能性を許すために、
@var{op}は最初に還元される必要があります。
その結果は、@w{@samp{1 - (2 @var{op} 3)}}となります。
逆に、@var{op}をシフトする前に減算を還元するならば、
結果は@w{@samp{(1 - 2) @var{op} 3}}となります。
明らかに、シフトと還元のどちらが起こるべきかの選択は、
演算子@samp{-}と@var{op}の相対的な優先順位に依存します。
@samp{*}は先にシフトされるべきですが、@samp{<}は違います。

@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 結合性
@w{@samp{1 - 2 - 5}}のような例ではどうなるでしょうか。
@w{@samp{(1 - 2) - 5}}と処理するべきでしょうか。
それとも、@w{@samp{1 - (2 - 5)}}と処理するべきでしょうか。
ほとんどの演算子については前者が適し、これを、
@dfn{左結合性（left association）}と呼びます。
後者の@dfn{右結合性（right association）}は、代入演算子に適します。
左結合性か右結合性かの判断は、スタックに@w{@samp{1 - 2}}が含まれ、
先読みトークンが@samp{-}である場合の、シフトか還元かの選択です。
シフトを選ぶと、右結合的になります。


@c =====================================================================
@node Using Precedence, Precedence Examples, Why Precedence, Precedence
@c @subsection Specifying Operator Precedence
@subsection 演算子の優先順位の指定
@findex %left
@findex %right
@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}宣言はすべての演算子を右結合的に宣言します。
第3の選択肢は@code{%nonassoc}宣言で、これで宣言した演算子が
続けて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}宣言で
宣言された演算子が、もっとも低い優先順位を持ちます。
後から宣言される演算子ほど、高い優先順位を持ちます。


@c =====================================================================
@node Precedence Examples, How Precedence, Using Precedence, Precedence
@c @subsection Precedence Examples
@subsection 優先順位の例

@c In our example, we would want the following declarations:

先ほどの例では、次のように宣言するべきでした。

@example
%left '<'
%left '-'
%left '*'
@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{'-'}演算子が同じ優先順位を持ちます。

@example
%left '<' '>' '=' NE LE GE
%left '+' '-'
%left '*' '/'
@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}は「等しくない」演算子を表し、他も同様です。
これらのトークンは、2文字以上からなるので、
1文字リテラルではなく名前で表されると仮定しています）


@c =====================================================================
@node How Precedence,  , Precedence Examples, Precedence
@c @subsection How Precedence Works
@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の働きは、規則に含まれる最後の終端記号が優先順位を示すように、
ある規則に優先順位を割り当てることです
（規則に対して、明示的に優先順位を指定することも可能です。
@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.

最後に、衝突の解決は、問題になっている規則の優先順位と、
先読みトークンの優先順位の比較によって行われます。
もし、先読みトークンの優先順位が高ければ、還元されます。
もし、規則の優先順位が高ければ、シフトされます。
もし、優先順位が同じならば、その優先順位での結合規則によって決定されます。
@samp{-v}オプションを付けて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
@c @section Context-Dependent Precedence
@section 文脈依存優先順位
@cindex context-dependent precedence
@cindex unary operator precedence
@cindex precedence, context-dependent
@cindex precedence, unary operator
@findex %prec
@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.

しばしば、演算子の優先順位は文脈に依存します。
これは、最初は奇異に感じるかもしれませんが、
実際によく起きていることなのです。
たとえば、通常、減算演算子（@samp{-}）は、
単項演算子としては非常に高い優先順位を持ちますが、
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}は、
あるトークンに対して1回のみ使え、この方法では、
トークンは唯一の優先順位を宣言されます。
文脈に依存する優先順位のためには、別の方法、すなわち、
@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}修飾子は、ある規則で使われるべき終端記号の優先順位を指定して、
その規則の優先順位を宣言します。
その記号がその規則の中以外に現れる必要はありません。
修飾子の記法は、次のようになっています。

@example
%prec @var{terminal-symbol}
@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}の優先順位を規則に割り当てます。
規則の優先順位が変更されて、その規則が関係している衝突の解決に影響します
（@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{UMINUS}という名前の終端記号に対する優先順位を宣言します。
この型のトークンは存在しませんが、
この記号が優先順位を表現するために使われます。

@example
@dots{}
%left '+' '-'
%left '*'
%left UMINUS
@end example

@c Now the precedence of @code{UMINUS} can be used in specific rules:

さて、@code{UNIMIS}の優先順位を、規則の中で使えます。

@example
@group
exp:    @dots{}
        | exp '-' exp
        @dots{}
        | '-' exp %prec UMINUS
@end group
@end example


@c =====================================================================
@node Parser States, Reduce/Reduce, Contextual Precedence, Algorithm
@c @section Parser States
@section 構文解析器の状態
@cindex finite-state machine
@cindex parser state
@cindex state (of parser)
@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}は、有限状態機械を使って実装されています。
構文解析器のスタックに積まれる値は、トークン型番号だけでなく、
スタックの先頭またはその近くにある終端記号と非終端記号の列を
表現しています。現在の状態は、次にすべきことに関連する、
今までの入力の情報全体の集まりです。

@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.

先読みトークンが読まれるたびに、先読みトークンの型と
現在の構文解析器の状態によって、表が引かれます。
この表の項目には、「先読みトークンをシフトしなさい」というような
ことが書かれています。この場合、その表の項目は、
先読みトークンが構文解析器スタックのトップに置かれた、
構文解析器の新しい状態をも示しています。
「@var{n}番目の規則を使って還元しなさい」というような項目もあります。
これによって、決められた数のトークンまたはグループがスタックのトップから
取り除かれ、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つの例外があります。
先読みトークンが現在の状態に対してエラーであるという項目もあります。
この場合には、エラー処理が起こります
（@pxref{Error Recovery}）。


@c =====================================================================
@node Reduce/Reduce, Mystery Conflicts, Parser States, Algorithm
@c @section Reduce/Reduce Conflicts
@section 還元/還元衝突
@cindex reduce/reduce conflict
@cindex conflicts, reduce/reduce
@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個以上の規則が適用可能であると、
還元/還元衝突が起きます。
これは、通常、文法の重大なエラーを意味します。

@c For example, here is an erroneous attempt to define a sequence
@c of zero or more @code{word} groupings.

0個以上の@code{word}の並びをグループ化する、
誤った試みの例を示します。

@example
@c sequence: /* empty */
sequence: /* 空 */
                @{ printf ("empty sequence\n"); @}
        | maybeword
        | sequence word
                @{ printf ("added word %s\n", $2); @}
        ;

@c maybeword: /* empty */
maybeword: /* 空 */
                @{ printf ("empty maybeword\n"); @}
        | word
                @{ printf ("single word %s\n", $1); @}
        ;
@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}に構文解析する、
2個以上の方法があります。
@code{word}は、@code{maybeword}に還元され、
第2の規則によって@code{sequence}になりえます。
また、最初の規則で、空データが@code{sequence}に還元され、
それが第3の規則によって@code{word}と組み合わされて
@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つ以上あります。
第1の規則で直接還元される方法と、
@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.

この違いは、特定の入力が正当であるかどうかに関係ないので、
ささいなことに思えるかもしれません。
しかし、これは、どのアクションが実行されるかに影響します。
ある構文解析手順では第2の規則のアクションが実行され、
別の構文解析手順では第1の規則のアクションと第3の規則のアクションが
実行されます。
この例では、プログラムの出力が異なります。

@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は、最初に現れた文法を選ぶことで、還元/還元衝突を解決しますが、
これに頼ることは非常に危険です。
還元/還元衝突のそれぞれは、人間によって解析され、
通常は取り除かれるべきです。
@code{sequence}を定義する正しい方法を示します。

@example
@c sequence: /* empty */
sequence: /* 空 */
                @{ printf ("empty sequence\n"); @}
        | sequence word
                @{ printf ("added word %s\n", $2); @}
        ;
@end example

@c Here is another common error that yields a reduce/reduce conflict:

還元/還元衝突を起こす、別のありがちなエラーの例を示します。

@example
@c sequence: /* empty */
sequence: /* 空 */
        | sequence words
        | sequence redirects
        ;

@c words:    /* empty */
words:    /* 空 */
        | words word
        ;

@c redirects:/* empty */
redirects:/* 空 */
        | redirects redirect
        ;
@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{sequence}、@code{words}、@code{redirects}それぞれ個別の
定義にエラーはありません。しかし、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}になったと仮定しましょう。
それは、2個の@code{words}にも、3個の@code{words}にも、
何個の@code{words}にもなりえます。
あるいは、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つあります。
第1に、1段階の列にする方法です。

@example
@c sequence: /* empty */
sequence: /* 空 */
        | sequence word
        | sequence redirect
        ;
@end example

@c Second, to prevent either a @code{words} or a @code{redirects}
@c from being empty:

第2に、@code{words}と@code{redirects}が空になるのを防ぐ方法です。
 
@example
@c sequence: /* empty */
sequence: /* 空 */
        | sequence words
        | sequence redirects
        ;

words:    word
        | words word
        ;

redirects:redirect
        | redirects redirect
        ;
@end example


@c =====================================================================
@node Mystery Conflicts, Stack Overflow, Reduce/Reduce, Algorithm
@c @section Mysterious Reduce/Reduce Conflicts
@section 不可解な還元/還元衝突

@c Sometimes reduce/reduce conflicts can occur that don't look warranted.
@c Here is an example:

そうなるはずがないように見えるのに、ときどき
還元/還元衝突が起きることがあります。
例を示します。

@example
@group
%token ID

%%
def:    param_spec return_spec ','
        ;
param_spec:
             type
        |    name_list ':' type
        ;
@end group
@group
return_spec:
             type
        |    name ':' type
        ;
@end group
@group
type:        ID
        ;
@end group
@group
name:        ID
        ;
name_list:
             name
        |    name ',' name_list
        ;
@end group
@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個のトークンの先読みによって、構文解析できるように見えます。
たとえば、@code{pram_spec}が読まれた後で、
@code{ID}はカンマかセミコロンが続くならば@code{name}、
そうでなければ@code{type}となります。
言い換えれば、この文法はLR(1)です。

@cindex LR(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は、多くの構文解析器生成器と同様に、
すべてのLR(1)文法を扱えるわけではありません。
前述の例では、@code{ID}の後で、そこが@code{param_spec}の先頭であるという
文脈と、そこが@code{return_spec}の先頭であるという文脈は、
Bisonが同一であるとみなしてしまうほど似ています。
これらの文脈が似てしまう原因は、同じ規則の集合が有効になる、つまり、
@code{name}へ還元するための規則と、@code{type}へ還元するための規則の
両方が有効なことです。
Bisonは、その規則が2つの文脈で異なる先読みトークンを要求するような、
処理の段階を決定できず、両者から1つの構文解析器状態ができてしまいます。
2個の文脈の組み合わせは、後で衝突を起こします。
構文解析器の用語でいえば、この問題の発生は、
文法が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)文法を扱える構文解析器生成器は、作成困難で、
生成される構文解析器が巨大になってしまいます。
実用上、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種類の構文解析器の
状態を区別し、それらが違うという目印か何かを追加することによって、
しばしば問題を解決できます。
前述の例では、次のように@code{return_spec}に規則を追加して、
問題を解決できます。

@example
@group
%token BOGUS
@dots{}
%%
@dots{}
return_spec:
             type
        |    name ':' type
@c         /* This rule is never used.  */
         /* この規則は決して使われない。  */
        |    ID BOGUS
        ;
@end group
@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{param_spec}に関連する文脈では有効にならないので、
2個の文脈は、異なる構文解析器状態を持ちます。
@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{ID}を直接使うように書き換えるのです。
@code{return_spec}に対する規則は、@code{name}に対する規則ではなく、
@code{return_spec}に対する規則を有効にするので、
2つの混乱していた文脈は異なる有効な規則の集まりを持ちます。

@example
param_spec:
             type
        |    name_list ':' type
        ;
return_spec:
             type
        |    ID ':' type
        ;
@end example


@c =====================================================================
@node Stack Overflow,  , Mystery Conflicts, Algorithm
@c @section Stack Overflow, and How to Avoid It
@section スタックオーバーフローと防ぎ方
@cindex stack overflow
@cindex parser stack overflow
@cindex overflow of parser stack
@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構文解析器のスタックは、あまりにも多くのトークンがシフトされて
還元されないでいると、オーバーフローする可能性があります。
スタックがオーバーフローすると、オーバーフローを報告するために@code{yyerror}
を呼び出して、関数@code{yyparse}は0でない値を返します。

@vindex YYMAXDEPTH
@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}を定義して、スタックオーバーフローが起こらないように、
構文解析器のスタックの深さを調節できます。
マクロの値として、整数値を定義してください。
この値は、オーバーフローする前に、シフトされたが還元されていないトークンの
最大数になります。
マクロの値として、コンパイル時に決定可能な定数式を指定してください。

@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}を小さくする必要はありません。

@cindex default stack limit
@cindex 省略時のスタックの限界
@cindex スタックの限界, 省略時
@c The default value of @code{YYMAXDEPTH}, if you do not define it, is
@c 10000.

特に指定しないと、@code{YYMAXDEPTH}の値は10000になります。

@vindex YYINITDEPTH
@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}を指定して、最初に割り当てられるスタックの量を
調節できます。この値は、コンパイル時に決定可能な整定数の必要があります。
特に指定しないと、200になります。


@c =====================================================================
@node Error Recovery, Context Dependency, Algorithm, Top
@c @chapter Error Recovery
@chapter エラーからの回復
@cindex error recovery
@cindex recovery from errors
@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行ごとに処理する単純な対話的構文解析器は、
エラーが発生した場合に@code{yyparse}が1を返し、
入力行の残りを無視し、
@code{yyparse}をもう一度呼び出してもかまいません。
しかし、コンパイラでこのように処理すると、
エラーに先立つ文法的文脈を忘れてしまうので不都合です。
深い関数呼び出しの中で構文エラーが発生した場合に、
コンパイラがエラーに続く行をソースファイルの先頭のように
扱うべきではありません。

@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}は定義済みの終端記号で、自分で宣言する必要はなく、
エラー処理のために予約されています。
Bison構文解析器は、構文エラーが起こるたびに、@code{error}トークンを生成します。
現在の文脈で@code{error}トークンを認識できる規則を書いていれば、
構文解析を継続できます。

@c For example:

例を示します。

@example
@c stmnts:  /* empty string */
stmnts:  /* 空文字列 */
        | stmnts '\n'
        | stmnts exp '\n'
        | stmnts error '\n'
@end example

@c The fourth rule in this example says that an error followed by a newline
@c makes a valid addition to any @code{stmnts}.

第4の規則は、@code{error}とそれに続く改行が、任意の@code{stmnts}に
続くことを認めます。

@c What happens if a syntax error occurs in the middle of an @code{exp}?  The
@c error recovery rule, interpreted strictly, applies to the precise sequence
@c of a @code{stmnts}, an @code{error} and a newline.  If an error occurs in
@c the middle of an @code{exp}, there will probably be some additional tokens
@c and subexpressions on the stack after the last @code{stmnts}, and there
@c will be tokens to read before the next newline.  So the rule is not
@c applicable in the ordinary way.

@code{exp}の中で構文エラーが発生するとどうなるでしょうか。
エラー回復規則は、厳密に解釈され、@code{stmnts}、@code{error}、改行からなる
列に適用されます。
@code{exp}の中で構文エラーが起きると、おそらく、いくつかの余分なトークンまたは
部分式がスタック上の最後の@code{stmnts}の後に存在し、
したがって、次の改行を読む前に読むべきトークンが存在するでしょう。
したがって、この通常の方法では規則を適用できません。

@c But Bison can force the situation to fit the rule, by discarding part of
@c the semantic context and part of the input.  First it discards states and
@c objects from the stack until it gets back to a state in which the
@c @code{error} token is acceptable.  (This means that the subexpressions
@c already parsed are discarded, back to the last complete @code{stmnts}.)  At
@c this point the @code{error} token can be shifted.  Then, if the old
@c look-ahead token is not acceptable to be shifted next, the parser reads
@c tokens and discards them until it finds a token which is acceptable.  In
@c this example, Bison reads and discards input until the next newline
@c so that the fourth rule can apply.

しかし、意味文脈と入力の一部を捨てることによって、
Bisonは強制的にこの場合に規則を適用できます。
まず、@code{error}トークンが受理可能な状態に戻るまで、
状態とオブジェクトがスタックから捨てられます
（これは、すでに構文解析された部分式が捨てられ、
最後の完全な@code{stmnts}に状態が戻ることを意味します）。
この時点で、@code{error}トークンがシフトされます。
そして、古い先読みトークンのシフトは受理不可能なので、
受理可能なトークンを見つけるまで、
構文解析器はトークンを読んで捨てます。
前述の例では、次の改行がくるまで入力が読み捨てられ、
したがって、第4の規則が適用可能になります。

@c The choice of error rules in the grammar is a choice of strategies for
@c error recovery.  A simple and useful strategy is simply to skip the rest of
@c the current input line or current statement if an error is detected:

文法中のエラー規則の選択は、エラー回復の戦略の選択です。
単純で便利な戦略の1つは、エラーを検出したら、
単純に現在の入力行または文を読み飛ばすことです。

@example
@c stmnt: error ';'  /* on error, skip until ';' is read */
stmnt: error ';'  /* エラーがあれば、「;」がくるまで読み飛ばす。 */
@end example

@c It is also useful to recover to the matching close-delimiter of an
@c opening-delimiter that has already been parsed.  Otherwise the
@c close-delimiter will probably appear to be unmatched, and generate another,
@c spurious error message:

すでに構文解析された開き区切りトークン
@c @footnote{【訳注】C言語での@samp{([@{}、
@c Pascal言語での@samp{begin}など。}
@c を、閉じ区切りトークンに対応させることは、
エラー処理のうまい方法です。そうしなければ、閉じ区切りトークンが
後で不適切に現れて、別の重大なエラーを引き起こすでしょう。

@example
primary:  '(' expr ')'
        | '(' error ')'
        @dots{}
        ;
@end example

@c Error recovery strategies are necessarily guesses.  When they guess wrong,
@c one syntax error often leads to another.  In the above example, the error
@c recovery rule guesses that an error is due to bad input within one
@c @code{stmnt}.  Suppose that instead a spurious semicolon is inserted in the
@c middle of a valid @code{stmnt}.  After the error recovery rule recovers
@c from the first error, another syntax error will be found straightaway,
@c since the text following the spurious semicolon is also an invalid
@c @code{stmnt}.

エラー回復の戦略は熟慮されるべきです。
戦略が悪いと、1つの構文エラーがしばしば別のエラーを引き起こします。
前述の例では、エラー回復規則は、1個の@code{stmnt}の中で起きると
仮定されています。
そうでない可能性として、有効な@code{stmnt}の中に誤ってセミコロンが
まぎれ込んでいることを考えてみましょう。
エラー回復規則が最初のエラーを回復した後で、まぎれ込んだセミコロンに続く
入力も無効な@code{stmnt}なので、もう1つの構文エラーがただちにみつかります。

@c To prevent an outpouring of error messages, the parser will output no error
@c message for another syntax error that happens shortly after the first; only
@c after three consecutive input tokens have been successfully shifted will
@c error messages resume.

エラー報告の洪水を避けるために、
最初の構文エラーが起きた直後の他の構文エラーに対しては、
構文解析器はエラー報告を表示しないべきでしょう。
3個の連続する入力トークンのシフトに成功してから、
エラー報告を再開するべきです。

@c Note that rules which accept the @code{error} token may have actions, just
@c as any other rules can.

@code{error}トークンを受け付ける規則も、他の規則と同様に
アクションを持てることに注意してください。

@findex yyerrok
@c You can make error messages resume immediately by using the macro
@c @code{yyerrok} in an action.  If you do this in the error rule's action, no
@c error messages will be suppressed.  This macro requires no arguments;
@c @samp{yyerrok;} is a valid C statement.

アクションの中でマクロ@code{yyerrok}を使って、
ただちにエラー報告を再開できます。
もし、エラー規則のアクションの中でこのマクロを使えば、
エラー報告は抑制されません。
このマクロに引数は不要で、@samp{yyerrok;}は有効なCの文です。

@findex yyclearin
@c The previous look-ahead token is reanalyzed immediately after an error.  If
@c this is unacceptable, then the macro @code{yyclearin} may be used to clear
@c this token.  Write the statement @samp{yyclearin;} in the error rule's
@c action.

直前の先読みトークンは、エラーの直後に再解析されます。
これが不都合ならば、マクロ@code{yyclearin}によって先読みトークンを
消してください。すなわち、エラー規則のアクションに
@samp{yyclearin;}文を書いてください。

@c For example, suppose that on a parse error, an error handling routine is
@c called that advances the input stream to some point where parsing should
@c once again commence.  The next symbol returned by the lexical scanner is
@c probably correct.  The previous look-ahead token ought to be discarded
@c with @samp{yyclearin;}.

たとえば、構文エラーにおいて、構文解析を再開すべき場所まで入力を進めるような、
エラー処理手続きを考えてみましょう。
字句解析器から返される次の記号は、おそらく正しいでしょう。
以前の先読みトークンは@samp{yyclearin;}によって捨てられるべきです。

@vindex YYRECOVERING
@c The macro @code{YYRECOVERING} stands for an expression that has the
@c value 1 when the parser is recovering from a syntax error, and 0 the
@c rest of the time.  A value of 1 indicates that error messages are
@c currently suppressed for new syntax errors.

マクロ@code{YYRECOVERING}は、式を表し、構文解析器がエラーから回復する
途中にあるならば値が1になり、通常の状態ならば値が0になります。
値が1であるということは、新たな構文エラーに対するエラーの報告が、
現在は抑制されていることを示します。


@c =====================================================================
@node Context Dependency, Debugging, Error Recovery, Top
@c @chapter Handling Context Dependencies
@chapter 文脈依存性の処理

@c The Bison paradigm is to parse tokens first, then group them into larger
@c syntactic units.  In many languages, the meaning of a token is affected by
@c its context.  Although this violates the Bison paradigm, certain techniques
@c (known as @dfn{kludges}) may enable you to write Bison parsers for such
@c languages.

Bisonの枠組みは、まずトークンを読み、
次にトークンをより大きな文法的単位にグループ化することです。
多くの言語では、トークンの意味は文脈の影響を受けます。
文脈依存性によってBisonの枠組みが壊れますが、
（@dfn{kludges}として知られる）いくつかの技術を使って、
このような言語に対するBison構文解析器を書けます。

@menu
* Semantic Tokens::   Token parsing can depend on the semantic context.
* Lexical Tie-ins::   Token parsing can depend on the syntactic context.
* Tie-in Recovery::   Lexical tie-ins have implications for how
                        error recovery rules must be written.
@end menu

@c (Actually, ``kludge'' means any technique that gets its job done but is
@c neither clean nor robust.)

（実際に、「kludge」は、仕事を可能にしますが、
美しくも頑丈でもない技術を意味します）


@c =====================================================================
@node Semantic Tokens, Lexical Tie-ins,  , Context Dependency
@c @section Semantic Info in Token Types
@section トークン型の意味情報

@c The C language has a context dependency: the way an identifier is used
@c depends on what its current meaning is.  For example, consider this:

C言語は文脈依存性をもっています。
すなわち、識別子の使われ方は、それの現在の意味に依存します。
次の例を考えてみてください。

@example
foo (x);
@end example

@c This looks like a function call statement, but if @code{foo} is a typedef
@c name, then this is actually a declaration of @code{x}.  How can a Bison
@c parser for C decide how to parse this input?

これは、関数を呼び出す文のように見えます。
しかし、もし、@code{foo}が@code{typedef}された型名ならば、
この文は@code{x}の宣言になります。
C言語に対するBison構文解析器は、この入力を構文解析する方法を
どのように決定できるでしょうか。

@c The method used in GNU C is to have two different token types,
@c @code{IDENTIFIER} and @code{TYPENAME}.  When @code{yylex} finds an
@c identifier, it looks up the current declaration of the identifier in order
@c to decide which token type to return: @code{TYPENAME} if the identifier is
@c declared as a typedef, @code{IDENTIFIER} otherwise.

GNU Cで使っている方法は、@code{IDENTIFIER}と@code{TYPENAME}という、
2種類の異なるトークン型を使うことです。
@code{yylex}が識別子を見つけると、どちらのトークン型を返すか決めるために、
識別子の現在の宣言を検索し、@code{typedef}として宣言されていれば
@code{TYPENAME}を返し、そうでなければ@code{IDENTIFIER}を返します。

@c The grammar rules can then express the context dependency by the choice of
@c token type to recognize.  @code{IDENTIFIER} is accepted as an expression,
@c but @code{TYPENAME} is not.  @code{TYPENAME} can start a declaration, but
@c @code{IDENTIFIER} cannot.  In contexts where the meaning of the identifier
@c is @emph{not} significant, such as in declarations that can shadow a
@c typedef name, either @code{TYPENAME} or @code{IDENTIFIER} is
@c accepted---there is one rule for each of the two token types.

そして、認識するトークン型を選ぶことによって、
文法規則は文脈依存性を表現できます。
@code{IDENTIFIER}は、式として受け入れられますが、
@code{TYPENAME}は受け入れられません。
@code{TYPENAME}は、宣言の始まりとして受け入れられますが、
@code{IDENTIFIER}は受け入れられません。
識別子の意味の区別が@emph{必要のない}文脈、
たとえば@code{typedef}名を隠す宣言の中では、
@code{TYPENAME}と@code{IDENTIFIER}の両方が受け入れられます。
すなわち、2個のトークン型に対してそれぞれ1個の規則を書くことが可能です。

@c This technique is simple to use if the decision of which kinds of
@c identifiers to allow is made at a place close to where the identifier is
@c parsed.  But in C this is not always so: C allows a declaration to
@c redeclare a typedef name provided an explicit type has been specified
@c earlier:

この方法は、どの種類の識別子が許されるかの判断が、
その識別子が構文解析される場所の近くで行われるならば、
単純に使えます。
しかし、C言語で、いつもそうであるとは限りません。
次の例のように、以前に指定された明示的な型に規定された@code{typedef}名の
再宣言が許されているからです。

@example
typedef int foo, bar, lose;
@c static foo (bar);        /* @r{redeclare @code{bar} as static variable} */
static foo (bar);        /* @r{@code{bar}を静的変数として再宣言する。} */
@c static int foo (lose);   /* @r{redeclare @code{foo} as function} */
static int foo (lose);   /* @r{@code{foo}を関数として再宣言する。} */
@end example

@c Unfortunately, the name being declared is separated from the declaration
@c construct itself by a complicated syntactic structure---the ``declarator''.

不幸にも、込み入った文法構造「宣言子(declarator)」によって、
宣言された名前は、その宣言の構造自身から切り離されます。

@c As a result, the part of Bison parser for C needs to be duplicated, with
@c all the nonterminal names changed: once for parsing a declaration in which
@c a typedef name can be redefined, and once for parsing a declaration in
@c which that can't be done.  Here is a part of the duplication, with actions
@c omitted for brevity:

結果として、C言語に対するBison構文解析器は、
すべての非終端記号の名前を変えて、二重化されました。
第1は、@code{typedef}名が再定義されているかもしれない宣言を構文解析し、
第2は、再定義が起こりえない宣言を構文解析します。
二重化したものの一部分を、簡単にするためにアクションを省略して、示します。

@example
initdcl:
          declarator maybeasm '='
          init
        | declarator maybeasm
        ;

notype_initdcl:
          notype_declarator maybeasm '='
          init
        | notype_declarator maybeasm
        ;
@end example

@c @noindent
@c Here @code{initdcl} can redeclare a typedef name, but @code{notype_initdcl}
@c cannot.  The distinction between @code{declarator} and
@c @code{notype_declarator} is the same sort of thing.

ここで、@code{initdcl}は@code{typedef}名を再宣言できますが、
@code{notype_initdcl}は再宣言できません。
@code{declarator}と@code{notype_declarator}の違いも同様です。

@c There is some similarity between this technique and a lexical tie-in
@c (described next), in that information which alters the lexical analysis is
@c changed during parsing by other parts of the program.  The difference is
@c here the information is global, and is used for other purposes in the
@c program.  A true lexical tie-in has a special-purpose flag controlled by
@c the syntactic context.

前述の技術と、後述の字句解析結び付きには、
字句解析に影響する情報が入力の別の部分を構文解析しているときに
変化させられるという、共通点があります。
前者では、情報が広域的で、プログラム@footnote{【訳注】構文解析器。}の別の目的に
使われることが異なります。
本当の字句解析結び付きは、文脈によって制御される、
特別の目的のフラグを持ちます。


@c =====================================================================
@node Lexical Tie-ins, Tie-in Recovery, Semantic Tokens, Context Dependency
@c @section Lexical Tie-ins
@section 字句解析結び付き
@cindex lexical tie-in
@cindex 字句解析結び付き

@c One way to handle context-dependency is the @dfn{lexical tie-in}: a flag
@c which is set by Bison actions, whose purpose is to alter the way tokens are
@c parsed.

文脈依存性を処理する1つの方法は、@dfn{字句解析結び付き（lexical tie-in）}で、
Bisonのアクションによって設定されるフラグが、
トークンが構文解析される方法に影響します。

@c For example, suppose we have a language vaguely like C, but with a special
@c construct @samp{hex (@var{hex-expr})}.  After the keyword @code{hex} comes
@c an expression in parentheses in which all integers are hexadecimal.  In
@c particular, the token @samp{a1b} must be treated as an integer rather than
@c as an identifier if it appears in that context.  Here is how you can do it:

たとえば、C言語によく似ていて、@samp{hex (@var{hex-expr})}という
特別な構造を持つ言語について、考えてみましょう。
予約語@code{hex}がきた後にかっこで囲まれた式が続いて、
そのかっこの中ではすべての整数が16進数になります。
特に、トークン@samp{a1b}は、このような文脈に現れれば、
識別子ではなく整数として扱われる必要があります。
どのようにすればよいかを示します。

@example
@group
%@{
int hexflag;
%@}
%%
@dots{}
@end group
@group
expr:   IDENTIFIER
        | constant
        | HEX '('
                @{ hexflag = 1; @}
          expr ')'
                @{ hexflag = 0;
                   $$ = $4; @}
        | expr '+' expr
                @{ $$ = make_sum ($1, $3); @}
        @dots{}
        ;
@end group

@group
constant:
          INTEGER
        | STRING
        ;
@end group
@end example

@c @noindent
@c Here we assume that @code{yylex} looks at the value of @code{hexflag}; when
@c it is nonzero, all integers are parsed in hexadecimal, and tokens starting
@c with letters are parsed as integers if possible.

@code{yylex}は、@code{hexflag}の値が0でなければ、
すべての整数が16進数であると字句解析し、
英字で始まるトークンも可能な限り整数と解釈すると、仮定します。

@c The declaration of @code{hexflag} shown in the C declarations section of
@c the parser file is needed to make it accessible to the actions 
@c (@pxref{C Declarations, ,The C Declarations Section}).
@c You must also write the code in @code{yylex} to obey the flag.

@code{hexflag}の宣言は、アクションから参照可能なように、
文法ファイルのC宣言部に書かれる必要があります
（@pxref{C Declarations, ,The C Declarations Section}）。
同様に、@code{yylex}のプログラムにも、@code{hexflag}の宣言が必要です。


@c =====================================================================
@node Tie-in Recovery,  , Lexical Tie-ins, Context Dependency
@c @section Lexical Tie-ins and Error Recovery
@section 字句解析結び付きとエラー回復

@c Lexical tie-ins make strict demands on any error recovery rules you have.
@c @xref{Error Recovery}.
字句解析結び付きは、厳密なエラー回復規則を要求します。
@xref{Error Recovery}。

@c The reason for this is that the purpose of an error recovery rule is to
@c abort the parsing of one construct and resume in some larger construct.
@c For example, in C-like languages, a typical error recovery rule is to skip
@c tokens until the next semicolon, and then start a new statement, like this:

その理由は、エラー回復規則の目的が、ある構成物の構文解析を中断し、
より大きな構成物の構文解析を再開することです。
前述のC言語に似ている言語の例では、次のように、
標準的なエラー回復規則は、次のセミコロンまでトークンを読み捨て、
新しい文の構文解析を再開します。

@example
stmt:   expr ';'
        | IF '(' expr ')' stmt @{ @dots{} @}
        @dots{}
        error ';'
                @{ hexflag = 0; @}
        ;
@end example

@c If there is a syntax error in the middle of a @samp{hex (@var{expr})}
@c construct, this error rule will apply, and then the action for the
@c completed @samp{hex (@var{expr})} will never run.  So @code{hexflag} would
@c remain set for the entire rest of the input, or until the next @code{hex}
@c keyword, causing identifiers to be misinterpreted as integers.

もし、@samp{hex (@var{expr})}の途中で構文エラーが発生すれば、
このエラー回復規則が適用され、完了した@samp{hex @var{expr})}に対する
アクションは決して実行されません。
すると、@code{hexflag}は、入力の残りの間ずっと設定されたままでいるか、
次の@code{hex}予約語の出現までそのままの状態でいて、
識別子が16進整数と誤解されます。

@c To avoid this problem the error recovery rule itself clears @code{hexflag}.

この問題を防ぐためには、エラー回復規則が
@code{hexflag}を元に戻すべきです。

@c There may also be an error recovery rule that works within expressions.
@c For example, there could be a rule which applies within parentheses
@c and skips to the close-parenthesis:

さらに、式の内部で働くエラー回復規則があるかもしれません。
たとえば、次の例のように、かっこの中でエラーが発生すると、
閉じかっこまで読み捨てるようなエラー回復規則が考えられます。

@example
@group
expr:   @dots{}
        | '(' expr ')'
                @{ $$ = $2; @}
        | '(' error ')'
        @dots{}
@end group
@end example

@c If this rule acts within the @code{hex} construct, it is not going to abort
@c that construct (since it applies to an inner level of parentheses within
@c the construct).  Therefore, it should not clear the flag: the rest of
@c the @code{hex} construct should be parsed with the flag still in effect.

もし、この規則が@code{hex}構造の中で働くならば、
その構造の中の内側のかっこに適用されるので、
構造を中断するべきではありません。
したがって、このアクションではフラグを戻すべきではなく、
@code{hex}構造の残りはフラグを有効にしたまま構文解析されるべきです。

@c What if there is an error recovery rule which might abort out of the
@c @code{hex} construct or might not, depending on circumstances?  There is no
@c way you can write the action to determine whether a @code{hex} construct is
@c being aborted or not.  So if you are using a lexical tie-in, you had better
@c make sure your error recovery rules are not of this kind.  Each rule must
@c be such that you can be sure that it always will, or always won't, have to
@c clear the flag.

状況に応じて、@code{hex}構造を中断できるかもしれないし、そうでないかもしれない
エラー回復規則があれば、どうなるでしょうか。
@code{hex}構造を中断すべきかどうか決定できるアクションを書けません。
そこで、もし、字句解析結び付きを使っているならば、
あなたが書いたエラー回復規則がそのようになっていないことを確かめるべきです。
それぞれの規則は、常にフラグを戻すべきか、あるいは常にフラグを戻さないべきか、
決定できるべきです。


@c =====================================================================
@node Debugging, Invocation, Context Dependency, Top
@c @chapter Debugging Your Parser
@chapter 構文解析器のデバッグ
@findex YYDEBUG
@findex yydebug
@cindex debugging
@cindex tracing the parser
@cindex 追跡, 構文解析器
@cindex 構文解析器の追跡

@c If a Bison grammar compiles properly but doesn't do what you want when it
@c runs, the @code{yydebug} parser-trace feature can help you figure out why.

もし、Bison文法ファイルが正しくコンパイルされたのに、
生成された構文解析器が思いどおりに動かない場合には、
@code{yydebug}構文解析器追跡機能が、調査の役に立つでしょう。

@c To enable compilation of trace facilities, you must define the macro
@c @code{YYDEBUG} when you compile the parser.  You could use
@c @samp{-DYYDEBUG=1} as a compiler option or you could put @samp{#define
@c YYDEBUG 1} in the C declarations section of the grammar file 
@c (@pxref{C Declarations, ,The C Declarations Section}).
@c Alternatively, use the @samp{-t} option when
@c you run Bison (@pxref{Invocation, ,Invoking Bison}).
@c We always define @code{YYDEBUG} so that
@c debugging is always possible.

追跡機能のコンパイルを有効にするためには、
構文解析器をコンパイルするときに、マクロ@code{YYDEBUG}を定義する必要があります。
そのためには、コンパイラのオプションに@samp{-DYYDEBUG=1}を指定するか、
あるいは、文法ファイルのC宣言部に@samp{#define YYDEBUG 1}と書いておく
必要があります（@pxref{C Declarations, ,The C Declarations Section}）。
あるいは、Bisonを実行するときに(@pxref{Invocation, ,Invoking Bison})、
@samp{-t}オプションを指定しておくと、
@code{YYDEBUG}が定義され、追跡が可能になります。

@c The trace facility uses @code{stderr}, so you must add @w{@code{#include
@c <stdio.h>}} to the C declarations section unless it is already there.

追跡機能は@code{stderr}を使うので、C宣言部に
@w{@code{#include <stdio.h>}}と書いておく必要があります。

@c Once you have compiled the program with trace facilities, the way to
@c request a trace is to store a nonzero value in the variable @code{yydebug}.
@c You can do this by making the C code do it (in @code{main}, perhaps), or
@c you can alter the value with a C debugger.

追跡機能付で構文解析器をコンパイルしたら、構文解析器の実行時に、
追跡機能を有効にするために、@code{yydebug}変数を0でない値にしてください。
C言語のプログラム(おそらく@code{main}関数の中)でこの変数に代入するか、
あるいは、デバッガでこの変数の値を変えればいいでしょう。

@c Each step taken by the parser when @code{yydebug} is nonzero produces a
@c line or two of trace information, written on @code{stderr}.  The trace
@c messages tell you these things:

@code{yydebug}が0でない場合、構文解析器はそれぞれの段階で、
1行まはた2行の追跡情報を生成し、@code{stderr}に出力します。
追跡情報には、次のような情報が含まれています。

@itemize @bullet
@item
@c Each time the parser calls @code{yylex}, what kind of token was read.
@c
構文解析器が@code{yylex}を呼ぶたびに、
読み込まれたトークンの種類が記録されます。

@item
@c Each time a token is shifted, the depth and complete contents of the
@c state stack (@pxref{Parser States}).
@c
トークンがシフトされるたびに、状態スタックの深さと完全な内容が
表示されます（@pxref{Parser States}）。

@item
@c Each time a rule is reduced, which rule it is, and the complete contents
@c of the state stack afterward.
@c
規則が還元されるたびに、どの規則が使われるか、そして、
還元後の状態スタックの完全な内容が記録されます。

@end itemize

@c To make sense of this information, it helps to refer to the listing file
@c produced by the Bison @samp{-v} option
@c (@pxref{Invocation, ,Invoking Bison})
@c This file
@c shows the meaning of each state in terms of positions in various rules, and
@c also what each state will do with each possible input token.  As you read
@c the successive trace messages, you can see that the parser is functioning
@c according to its specification in the listing file.  Eventually you will
@c arrive at the place where something undesirable happens, and you will see
@c which parts of the grammar are to blame.

この情報を理解するためには、Bisonに@samp{-v}オプション
（@pxref{Invocation, ,Invoking Bison}）を付けて実行すると生成される
明細ファイルが参考になるでしょう。
このファイルには、さまざまな規則の中での位置による表現で
各状態の意味が示され、また、
各状態がそれぞれの可能な入力トークンによって
どのように動作するかが示されています。
連続する追跡の意味を読むことによって、
明細ファイルで仕様が示されている構文解析器の機能について、理解できるでしょう。
何か望ましくないことが起きている部分を確認すれば、
文法ファイルのどこに問題があるかわかるでしょう。

@c The parser file is a C program and you can use C debuggers on it, but it's
@c not easy to interpret what it is doing.  The parser function is a
@c finite-state machine interpreter, and aside from the actions it executes
@c the same code over and over.  Only the values of variables show where in
@c the grammar it is working.

構文解析器ファイルはC言語のプログラムなので、
Cのデバッガを使えますが、
何が起きているか調べることは困難です。
構文解析器関数は、有限状態機械インタープリタで、
アクションが実行されると、
プログラムの同じ部分が何度も何度も実行されます。
実用的なのは文法の中で変数の値を調べることだけでしょう。

@findex YYPRINT
@c The debugging information normally gives the token type of each token
@c read, but not its semantic value.  You can optionally define a macro
@c named @code{YYPRINT} to provide a way to print the value.  If you define
@c @code{YYPRINT}, it should take three arguments.  The parser will pass a
@c standard I/O stream, the numeric code for the token type, and the token
@c value (from @code{yylval}).

デバッグ情報には、通常、それぞれのトークンのトークン型だけが含まれ、
トークンの意味値は含まれません。
マクロ@code{YYPRINT}を定義することで、
トークンの意味値を表示させられます。
@code{YYPRINT}の定義には、3個の引数がともないます。
構文解析器は、@code{YYPRINT}に、標準入出力ストリーム、
トークン型の数値番号、トークンの値（@code{yylval}による）を渡します。

@c Here is an example of @code{YYPRINT} suitable for the multi-function
@c calculator (@pxref{Mfcalc Decl, ,Declarations for @code{mfcalc}}):

多機能電卓に適する@code{YYPRINT}の例を示します
（@pxref{Mfcalc Decl, ,Declarations for @code{mfcalc}}）。

@smallexample
#define YYPRINT(file, type, value)   yyprint (file, type, value)

static void
yyprint (file, type, value)
     FILE *file;
     int type;
     YYSTYPE value;
@{
  if (type == VAR)
    fprintf (file, " %s", value.tptr->name);
  else if (type == NUM)
    fprintf (file, " %d", value.val);
@}
@end smallexample


@c =====================================================================
@node Invocation, Table of Symbols, Debugging, Top
@c @chapter Invoking Bison
@chapter Bisonの実行
@cindex invoking Bison
@cindex Bison invocation
@cindex options for invoking Bison
@cindex Bisonの実行
@cindex 実行, Bison
@cindex Bison実行のオプション
@cindex オプション, Bison実行

@c The usual way to invoke Bison is as follows:

通常、Bisonは次のように実行します。

@example
bison @var{infile}
@end example

@c Here @var{infile} is the grammar file name, which usually ends in
@c @samp{.y}.  The parser file's name is made by replacing the @samp{.y}
@c with @samp{.tab.c}.  Thus, the @samp{bison foo.y} filename yields
@c @file{foo.tab.c}, and the @samp{bison hack/foo.y} filename yields
@c @file{hack/foo.tab.c}.@refill

ここで、@var{infile}は文法ファイルで、名前が通常@samp{.y}で終わります。
生成される構文解析器ファイルは、文法ファイルの名前の@samp{.y}を
@samp{.tab.c}に変えたものです。
したがって、@samp{bison foo.y}によって@samp{foo.tab.c}を得られますし、
@samp{bison hack/foo.y}によって@samp{hack/foo.tab.c}を得られます。

@menu
* Bison Options::     All the options described in detail, 
			in alphabetical order by short options.
* Option Cross Key::  Alphabetical list of long options.
* VMS Invocation::    Bison command syntax on VMS.
@end menu


@c =====================================================================
@node Bison Options, Option Cross Key,  , Invocation
@c @section Bison Options
@section Bisonのオプション

@c Bison supports both traditional single-letter options and mnemonic long
@c option names.  Long option names are indicated with @samp{--} instead of
@c @samp{-}.  Abbreviations for option names are allowed as long as they
@c are unique.  When a long option takes an argument, like
@c @samp{--file-prefix}, connect the option name and the argument with
@c @samp{=}.

Bisonは、伝統的な1文字のオプションと、記憶しやすい長いオプション名の
両方を受け付けます。長いオプション名は、@samp{-}の代わりに、
@samp{--}で指定します。
一意性を失わない範囲で、長いオプション名を省略できます。
長いオプションが引数をともなう場合、たとえば、@samp{--file-prefix}では、
オプション名と引数の間に@samp{=}を入れます。

@c Here is a list of options that can be used with Bison, alphabetized by
@c short option.  It is followed by a cross key alphabetized by long
@c option.

Bisonに対して指定可能なオプションの一覧を、アルファベット順に示します。
さらに、長い名前のアルファベット順の対応を示します。

@table @samp
@item -b @var{file-prefix}
@itemx --file-prefix=@var{prefix}
@c Specify a prefix to use for all Bison output file names.  The names are
@c chosen as if the input file were named @file{@var{prefix}.c}.
@c
Bisonが生成するすべてのファイルの名前の前半部分を指定します。
入力される文法ファイルの名前が@file{@var{prefix}.y}であった場合と、
同じ結果を得られます。

@item -d
@itemx --defines
@c Write an extra output file containing macro definitions for the token
@c type names defined in the grammar and the semantic value type
@c @code{YYSTYPE}, as well as a few @code{extern} variable declarations.
@c
文法ファイル中で定義されたトークン型名に対するマクロ定義、
意味値型@code{YYSTYPE}、いくつかの@code{extern}変数宣言を含む、
追加の出力ファイルを生成します。

@c If the parser output file is named @file{@var{name}.c} then this file
@c is named @file{@var{name}.h}.@refill

生成される構文解析ファイルの名前が@file{@var{name}.c}ならば、
このファイルの名前は@file{@var{name}.h}になります。

@c This output file is essential if you wish to put the definition of
@c @code{yylex} in a separate source file, because @code{yylex} needs to
@c be able to refer to token type codes and the variable
@c @code{yylval}.  @xref{Token Values, ,Semantic Values of Tokens}.@refill

@code{yylex}関数を独立なソースファイルの中で定義しているならば、
それはトークン型番号と変数@code{yylval}を必要とするので、
このファイルを@code{#include}する必要があります
@xref{Token Values, ,Semantic Values of Tokens}。

@item -l
@itemx --no-lines
@c Don't put any @code{#line} preprocessor commands in the parser file.
@c Ordinarily Bison puts them in the parser file so that the C compiler
@c and debuggers will associate errors with your source file, the
@c grammar file.  This option causes them to associate errors with the
@c parser file, treating it as an independent source file in its own right.
@c
構文解析器ファイルの中に、@code{#line}プリプロセッサディレクティブを生成しません。
通常、Bisonはこれを生成し、Cコンパイラとデバッガが、
文法ファイルのどこでエラーが発生したかを見つけるために使います。
このオプションは、エラーと構文解析器の行番号を結び付け、
構文解析器を独立なソースファイルとして扱います。

@item -n
@itemx --no-parser
@c Do not include any C code in the parser file; generate tables only.  The
@c parser file contains just @code{#define} directives and static variable
@c declarations.
@c
構文解析器にCのプログラムを含めず、表だけを生成します。
構文解析器ファイルは、@code{#define}ディレクティブと
静的変数の宣言のみからなります。

@c This option also tells Bison to write the C code for the grammar actions
@c into a file named @file{@var{filename}.act}, in the form of a
@c brace-surrounded body fit for a @code{switch} statement.

このオプションにより、@file{@var{filename}.act}という名前のファイルに、
文法アクションに対するC言語のプログラムが書かれます。
その書式は、@code{switch}文に対応するブレースで囲まれたブロックです。

@item -o @var{outfile}
@itemx --output-file=@var{outfile}
@c Specify the name @var{outfile} for the parser file.
@c
生成される構文解析器ファイルの名前を指定します。

@c The other output files' names are constructed from @var{outfile}
@c as described under the @samp{-v} and @samp{-d} options.
他の出力ファイルのファイル名の指定は
@samp{-v}と@samp{-d}オプションの項を参照してください。

@item -p @var{prefix}
@itemx --name-prefix=@var{prefix}
@c Rename the external symbols used in the parser so that they start with
@c @var{prefix} instead of @samp{yy}.  The precise list of symbols renamed
@c is @code{yyparse}, @code{yylex}, @code{yyerror}, @code{yynerrs},
@c @code{yylval}, @code{yychar} and @code{yydebug}.
@c
構文解析器が使う外部名を@samp{yy}でなく@var{prefix}で始まるように変えます。
影響を受ける名前は、
@code{yyparse}、@code{yylex}、@code{yyerror}、@code{yynerrs}、
@code{yylval}、@code{yychar}、@code{yydebug}です。

@c For example, if you use @samp{-p c}, the names become @code{cparse},
@c @code{clex}, and so on.

たとえば、@samp{-p c}オプションを指定すれば、
名前は@code{cparse}、@code{clex}などになります。

@c @xref{Multiple Parsers, ,Multiple Parsers in the Same Program}.

@xref{Multiple Parsers, ,Multiple Parsers in the Same Program}。

@item -r
@itemx --raw
@c Pretend that @code{%raw} was specified.  @xref{Decl Summary}.
@c
@code{%raw}が指定されたように振る舞います。
@xref{Decl Summary}。

@item -t
@itemx --debug
@c Output a definition of the macro @code{YYDEBUG} into the parser file,
@c so that the debugging facilities are compiled.
@c @xref{Debugging, ,Debugging Your Parser}.
@c
デバッグ機能がコンパイルされるように、
マクロ@code{YYDEBUG}の定義を構文解析器ファイルに入れます
@xref{Debugging, ,Debugging Your Parser}。

@item -v
@itemx --verbose
@c Write an extra output file containing verbose descriptions of the
@c parser states and what is done for each type of look-ahead token in
@c that state.
@c
構文解析器の状態についての詳細な説明と、
それらの状態でそれぞれの先読みトークンが現れると何が起きるか記述した、
追加のファイルを生成します。

@c This file also describes all the conflicts, both those resolved by
@c operator precedence and the unresolved ones.

このファイルは、演算子の優先順位によって解決したものも解決しなかった
ものも含めて、衝突についての説明を含んでいます。

@c The file's name is made by removing @samp{.tab.c} or @samp{.c} from
@c the parser output file name, and adding @samp{.output} instead.@refill

生成されるファイルの名前は、構文解析器のファイルの名前から、
@samp{.tab.c}または@samp{.c}を取り除いて、
代わりに@samp{.output}を付けたものです。

@c Therefore, if the input file is @file{foo.y}, then the parser file is
@c called @file{foo.tab.c} by default.  As a consequence, the verbose
@c output file is called @file{foo.output}.@refill

したがって、入力の文法ファイルの名前が@file{foo.y}ならば、
特に指定しないと、構文解析器ファイルの名前は@file{foo.tab.c}になり、
詳細な説明のファイルの名前は@file{foo.output}になります。

@item -V
@itemx --version
@c Print the version number of Bison and exit.
@c
バージョン番号を表示して、Bisonを終了させます。

@item -h
@itemx --help
@c Print a summary of the command-line options to Bison and exit.
@c
コマンドラインオプションの要約を表示して、Bisonを終了させます。

@need 1750
@item -y
@itemx --yacc
@itemx --fixed-output-files
@c Equivalent to @samp{-o y.tab.c}; the parser output file is called
@c @file{y.tab.c}, and the other outputs are called @file{y.output} and
@c @file{y.tab.h}.  The purpose of this option is to imitate Yacc's output
@c file name conventions.  Thus, the following shell script can substitute
@c for Yacc:@refill
@c
@samp{-o y.tab.c}と等価です。構文解析器ファイルの名前は
@file{y.tab.c}になり、他の出力ファイルの名前は@file{y.output}と
@file{y.tab.h}になります。このオプションの目的は、
出力ファイルの名前をYaccに合わせることです。
次のシェルスクリプトは、Yaccの代用になります。

@example
bison -y $*
@end example
@end table


@c =====================================================================
@node Option Cross Key, VMS Invocation, Bison Options, Invocation
@c @section Option Cross Key
@section オプション対応表

@c Here is a list of options, alphabetized by long option, to help you find
@c the corresponding short option.

オプションを、長い名前のアルファベット順に一覧表記して、
対応する1文字オプションを書きます。

@tex
\def\leaderfill{\leaders\hbox to 1em{\hss.\hss}\hfill}

{\tt
\line{ --debug \leaderfill -t}
\line{ --defines \leaderfill -d}
\line{ --file-prefix \leaderfill -b}
\line{ --fixed-output-files \leaderfill -y}
\line{ --help \leaderfill -h}
\line{ --name-prefix \leaderfill -p}
\line{ --no-lines \leaderfill -l}
\line{ --no-parser \leaderfill -n}
\line{ --output-file \leaderfill -o}
\line{ --raw \leaderfill -r}
\line{ --token-table \leaderfill -k}
\line{ --verbose \leaderfill -v}
\line{ --version \leaderfill -V}
\line{ --yacc \leaderfill -y}
}
@end tex

@ifinfo
@example
--debug                               -t
--defines                             -d
--file-prefix=@var{prefix}                  -b @var{file-prefix}
--fixed-output-files --yacc           -y
--help                                -h
--name-prefix=@var{prefix}                  -p @var{name-prefix}
--no-lines                            -l
--no-parser                           -n
--output-file=@var{outfile}                 -o @var{outfile}
--raw                                 -r			
--token-table                         -k
--verbose                             -v
--version                             -V
@end example
@end ifinfo


@c =====================================================================
@node VMS Invocation,  , Option Cross Key, Invocation
@c @section Invoking Bison under VMS
@section VMS上での実行
@cindex invoking Bison under VMS
@cindex VMS
@cindex 実行, VMS上

@c The command line syntax for Bison on VMS is a variant of the usual
@c Bison command syntax---adapted to fit VMS conventions.

VMS上のBisonのコマンドライン構文は、VMSの慣習に合わせて、
他のシステム上のBisonのコマンドライン構文と異なっています。

@c To find the VMS equivalent for any Bison option, start with the long
@c option, and substitute a @samp{/} for the leading @samp{--}, and
@c substitute a @samp{_} for each @samp{-} in the name of the long option.
@c For example, the following invocation under VMS:

VMSでは、すべてのBisonのオプションについて、
@samp{--}の代わりに@samp{/}に続く長い名前のオプションを書き、
オプション名中の@samp{-}を@samp{_}に変えます。
VMS上での実行例を示します。

@example
bison /debug/name_prefix=bar foo.y
@end example

@c @noindent
@c is equivalent to the following command under POSIX.

これは、POSIX上での次のコマンドラインと等価です。

@example
bison --debug --name-prefix=bar foo.y
@end example

@c The VMS file system does not permit filenames such as
@c @file{foo.tab.c}.  In the above example, the output file
@c would instead be named @file{foo_tab.c}.

VMSファイルシステムでは、@file{foo.tab.c}のようなファイル名が許されないので、
構文解析器の名前は、上記の例の場合には、@file{foo_tab.c}になります。


@c =====================================================================
@node Table of Symbols, Glossary, Invocation, Top
@c @appendix Bison Symbols
@appendix Bisonの記号一覧
@cindex Bison symbols, table of
@cindex symbols in Bison, table of
@cindex 記号一覧, Bison
@cindex Bisonの記号一覧

@table @code
@item error
@c A token name reserved for error recovery.  This token may be used in
@c grammar rules so as to allow the Bison parser to recognize an error in
@c the grammar without halting the process.  In effect, a sentence
@c containing an error may be recognized as valid.  On a parse error, the
@c token @code{error} becomes the current look-ahead token.  Actions
@c corresponding to @code{error} are then executed, and the look-ahead
@c token is reset to the token that originally caused the violation.
@c @xref{Error Recovery}.
@c
エラー回復のために予約されているトークン名です。
このトークンが文法規則の中で使われていると、Bison構文解析器は、
構文エラーを認識し、プロセスの実行を中断しません。
実質的には、エラーを含む文が、有効であると認識されます。
エラーが起きると、@code{error}トークンが現在の先読みトークンになります。
@code{error}に対応するアクションが実行されて、
先読みトークンがエラーの原因になったトークンに戻されます。
@xref{Error Recovery}。

@item YYABORT
@c Macro to pretend that an unrecoverable syntax error has occurred, by
@c making @code{yyparse} return 1 immediately.  The error reporting
@c function @code{yyerror} is not called.
@c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
@c
回復不可能な構文エラーが発生した場合のためのマクロで、
実行するとただちに@code{yyparse}が1を返します。
エラー報告関数@code{yyerror}は呼び出されません。
@xref{Parser Function, ,The Parser Function @code{yyparse}}。

@item YYACCEPT
@c Macro to pretend that a complete utterance of the language has been
@c read, by making @code{yyparse} return 0 immediately.  
@c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
@c
構文解析器が言語を完全に読み終えた場合のためのマクロで、
実行するとただちに@code{yyparse}が0を返します。
@xref{Parser Function, ,The Parser Function @code{yyparse}}。

@item YYBACKUP
@c Macro to discard a value from the parser stack and fake a look-ahead
@c token.
@c @xref{Action Features, ,Special Features for Use in Actions}.
@c
構文解析器のスタックから1個の値を捨て、先読みトークンのふりをさせます。
@xref{Action Features, ,Special Features for Use in Actions}。

@item YYERROR
@c Macro to pretend that a syntax error has just been detected: call
@c @code{yyerror} and then perform normal error recovery if possible
@c (@pxref{Error Recovery}), or (if recovery is impossible) make
@c @code{yyparse} return 1.
@c @xref{Error Recovery}.
@c
構文エラーがちょうど検出された場合のためのマクロで、
@code{yyerror}を呼び、可能ならば通常のエラー回復処理
（@pxref{Error Recovery}）を実行し、不可能ならば
@code{yyparse}が1を返します。
@xref{Error Recovery}。

@item YYERROR_VERBOSE
@c Macro that you define with @code{#define} in the Bison declarations
@c section to request verbose, specific error message strings when
@c @code{yyerror} is called.
Bison宣言部で@code{#define}によってこのマクロを定義すると、
@code{yyerror}が呼ばれたときに表示されるエラー報告が詳しくなります。

@item YYINITDEPTH
@c Macro for specifying the initial size of the parser stack.
@c @xref{Stack Overflow}.
@c
構文解析器スタックの最初の大きさを指定するマクロです。
@xref{Stack Overflow}。

@item YYLEX_PARAM
@c Macro for specifying an extra argument (or list of extra arguments) for
@c @code{yyparse} to pass to @code{yylex}.
@c @xref{Pure Calling,, Calling Conventions for Pure Parsers}.
@c
@code{yyparse}が@code{yylex}に渡すための、追加の引数または
引数の並びを指定するためのマクロです。
@xref{Pure Calling,, Calling Conventions for Pure Parsers}。

@item YYLTYPE
@c Macro for the data type of @code{yylloc}; a structure with four
@c members.
@c @xref{Token Positions, ,Textual Positions of Tokens}.
@c
@code{yyloc}のデータ型を示すマクロで、4個のメンバからなる構造体です。
@xref{Token Positions, ,Textual Positions of Tokens}。

@item yyltype
@c Default value for YYLTYPE.
@c
@code{YYLTYPE}の省略時の値です。

@item YYMAXDEPTH
@c Macro for specifying the maximum size of the parser stack.
@c @xref{Stack Overflow}.
@c
構文解析器のスタックの最大の大きさを指定するマクロです。
@xref{Stack Overflow}。

@item YYPARSE_PARAM
@c Macro for specifying the name of a parameter that @code{yyparse} should
@c accept.
@c @xref{Pure Calling,, Calling Conventions for Pure Parsers}.
@c
@code{yyparse}が受け取るべき引数の名前を指定するマクロです。
@xref{Pure Calling,, Calling Conventions for Pure Parsers}。

@item YYRECOVERING
@c Macro whose value indicates whether the parser is recovering from a
@c syntax error.
@c @xref{Action Features, ,Special Features for Use in Actions}.
@c
構文解析器が構文エラーから回復している途中かどうかを示す値のマクロです。
@xref{Action Features, ,Special Features for Use in Actions}。

@item YYSTYPE
@c Macro for the data type of semantic values; @code{int} by default.
@c @xref{Value Type, ,Data Types of Semantic Values}.
@c
意味値のデータ型を指定するためのマクロで、省略すると@code{int}になります。
@xref{Value Type, ,Data Types of Semantic Values}。

@item yychar
@c External integer variable that contains the integer value of the
@c current look-ahead token.  (In a pure parser, it is a local variable
@c within @code{yyparse}.)  Error-recovery rule actions may examine this
@c variable.
@c @xref{Action Features, ,Special Features for Use in Actions}.
@c
広域的な@code{int}型の変数で、現在の先読みトークンの番号を記憶しています
（再入可能な構文解析器では、この変数は@code{yyparse}に局所的です）。
エラー回復規則のアクションは、この変数の値を調べられます。
@xref{Action Features, ,Special Features for Use in Actions}。

@item yyclearin
@c Macro used in error-recovery rule actions.  It clears the previous
@c look-ahead token.
@c @xref{Error Recovery}.
@c
エラー回復規則のアクションで使われるマクロです。
直前の先読みトークンを消去します。
@xref{Error Recovery}。

@item yydebug
@c External integer variable set to zero by default.  If @code{yydebug}
@c is given a nonzero value, the parser will output information on input
@c symbols and parser action.
@c @xref{Debugging, ,Debugging Your Parser}.
@c
@code{int}型の広域変数で、初期値は0です。
@code{yydebug}の値が0でないと、構文解析器は、
読み込んだ記号と構文解析器のアクションに関する情報を表示します。
@xref{Debugging, ,Debugging Your Parser}。

@item yyerrok
@c Macro to cause parser to recover immediately to its normal mode
@c after a parse error.
@c @xref{Error Recovery}.
@c
構文エラーの後で、構文解析器をただちに通常の状態に戻すためのマクロです。
@xref{Error Recovery}。

@item yyerror
@c User-supplied function to be called by @code{yyparse} on error.  The
@c function receives one argument, a pointer to a character string
@c containing an error message.
@c @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
@c
エラーが起きたときに@code{yyparse}から呼び出される、ユーザー定義関数です。
この関数は1個の引数を受け取り、その引数はエラーの報告を含む文字列への
ポインタです。
@xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}。

@item yylex
@c User-supplied lexical analyzer function, called with no arguments
@c to get the next token.
@c @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}.
@c 
ユーザー定義の字句解析関数で、次のトークンを得るために、
引数なしで呼び出されます。
@xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。

@item yylval
@c External variable in which @code{yylex} should place the semantic
@c value associated with a token.  (In a pure parser, it is a local
@c variable within @code{yyparse}, and its address is passed to
@c @code{yylex}.)
@c @xref{Token Values, ,Semantic Values of Tokens}.
@c
トークンに関連する意味値を@code{yylex}が置くための広域変数です
（再入可能な構文解析器では、これは@code{yyparse}の局所変数で、
その番地が@code{yylex}に渡されます）。
@xref{Token Values, ,Semantic Values of Tokens}。

@item yylloc
@c External variable in which @code{yylex} should place the line and
@c column numbers associated with a token.  (In a pure parser, it is a
@c local variable within @code{yyparse}, and its address is passed to
@c @code{yylex}.)  You can ignore this variable if you don't use the
@c @samp{@@} feature in the grammar actions.
@c @xref{Token Positions, ,Textual Positions of Tokens}.
@c
トークンに関連する行番号と桁番号を@code{yylex}が置くための
広域変数です（再入可能な構文解析器では、この変数は@code{yyparse}に
局所的で、その番地が@code{yylex}に渡されます）。
文法アクションで@samp{@@}機能を使わないならば、
この値を無視してかまいません。
@xref{Token Positions, ,Textual Positions of Tokens}。

@item yynerrs
@c Global variable which Bison increments each time there is a parse
@c error.  (In a pure parser, it is a local variable within
@c @code{yyparse}.)
@c @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
@c
構文エラーが発生するたびにBisonが値を1増やす広域変数です
（再入可能な構文解析器では、この変数は@code{yyparse}に局所的です）。
@xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}。

@item yyparse
@c The parser function produced by Bison; call this function to start
@c parsing.
@c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
@c
Bisonによって生成される構文解析器関数で、
この関数を呼び出すことによって構文解析が始まります。
@xref{Parser Function, ,The Parser Function @code{yyparse}}。

@item %left
@c Bison declaration to assign left associativity to token(s).
@c @xref{Precedence Decl, ,Operator Precedence}.
@c
トークンに左結合性を与えるBison宣言です。
@xref{Precedence Decl, ,Operator Precedence}。

@item %no_lines
@c Bison declaration to avoid generating @code{#line} directives in the
@c parser file.
@c @xref{Decl Summary}.
@c
構文解析器ファイルの中に@code{#line}ディレクティブを生成しないための
Bison宣言です。
@xref{Decl Summary}。

@item %nonassoc
@c Bison declaration to assign nonassociativity to token(s).
@c @xref{Precedence Decl, ,Operator Precedence}.
@c
トークンに非結合性を与えるためのBison宣言です。
@xref{Precedence Decl, ,Operator Precedence}。

@item %prec
@c Bison declaration to assign a precedence to a specific rule.
@c @xref{Contextual Precedence, ,Context-Dependent Precedence}.
@c
指定された規則に優先順位を与えるためのBison宣言です。
@xref{Contextual Precedence, ,Context-Dependent Precedence}。

@item %pure_parser
@c Bison declaration to request a pure (reentrant) parser.
@c @xref{Pure Decl, ,A Pure (Reentrant) Parser}.
@c
再入可能な構文解析器を生成するためのBison宣言です。
@xref{Pure Decl, ,A Pure (Reentrant) Parser}。

@item %raw
@c Bison declaration to use Bison internal token code numbers in token
@c tables instead of the usual Yacc-compatible token code numbers.
@c @xref{Decl Summary}.
@c
通常のYacc互換トークン番号の代わりに、
トークン表のBison内部トークン番号を使うための、Bison宣言です。
@xref{Decl Summary}。

@item %right
@c Bison declaration to assign right associativity to token(s).
@c @xref{Precedence Decl, ,Operator Precedence}.
@c
トークンに右結合性を与えるためのBison宣言です。
@xref{Precedence Decl, ,Operator Precedence}。

@item %start
@c Bison declaration to specify the start symbol.
@c @xref{Start Decl, ,The Start-Symbol}.
@c
開始記号を指定するためのBison宣言です。
@xref{Start Decl, ,The Start-Symbol}。

@item %token
@c Bison declaration to declare token(s) without specifying precedence.
@c @xref{Token Decl, ,Token Type Names}.
@c
優先順位を指定せずにトークンを宣言するためのBison宣言です。
@xref{Token Decl, ,Token Type Names}。

@item %token_table
@c Bison declaration to include a token name table in the parser file.
@c @xref{Decl Summary}.
@c
構文解析器ファイルの中でトークン名の表を挿入するためのBison宣言です。
@xref{Decl Summary}。

@item %type
@c Bison declaration to declare nonterminals.
@c @xref{Type Decl, ,Nonterminal Symbols}.
@c
非終端記号を宣言するためのBison宣言です。
@xref{Type Decl, ,Nonterminal Symbols}。

@item %union
@c Bison declaration to specify several possible data types for semantic
@c values.
@c @xref{Union Decl, ,The Collection of Value Types}.
@c
意味値として可能ないくつかのデータ型を指定するためのBison宣言です。
@xref{Union Decl, ,The Collection of Value Types}.
@end table

@c These are the punctuation and delimiters used in Bison input:

Bison文法ファイルの中で使う、区切り記号があります。

@table @samp
@item %%
@c Delimiter used to separate the grammar rule section from the
@c Bison declarations section or the additional C code section.
@c @xref{Grammar Layout, ,The Overall Layout of a Bison Grammar}.
@c
Bison宣言部、文法規則部、（省略可能な）Cプログラム部を区切る記号です。
@xref{Grammar Layout, ,The Overall Layout of a Bison Grammar}。

@item %@{ %@}
@c All code listed between @samp{%@{} and @samp{%@}} is copied directly
@c to the output file uninterpreted.  Such code forms the ``C
@c declarations'' section of the input file.
@c @xref{Grammar Outline, ,Outline of a Bison Grammar}.
@c
文法ファイルの@samp{%@{}と@samp{%@}}の間に書かれたすべてのプログラムは、
そのまま構文解析器ファイルに複写されます。
このようなプログラムが、文法ファイルのC宣言部を構成します。
@xref{Grammar Outline, ,Outline of a Bison Grammar}。

@item /*@dots{}*/
@c Comment delimiters, as in C.
@c
C言語と同様のコメントです。

@item :
@c Separates a rule's result from its components.
@c @xref{Rules, ,Syntax of Grammar Rules}.
規則の結果と構成要素を分離する記号です。
@xref{Rules, ,Syntax of Grammar Rules}。

@item ;
@c Terminates a rule.
@c @xref{Rules, ,Syntax of Grammar Rules}.
@c
規則の終わりの記号です。
@xref{Rules, ,Syntax of Grammar Rules}。

@item |
@c Separates alternate rules for the same result nonterminal.
@c @xref{Rules, ,Syntax of Grammar Rules}.
@c
同一の非終端記号を結果とする複数の規則を区切る記号です。
@xref{Rules, ,Syntax of Grammar Rules}。
@end table


@c =====================================================================
@node Glossary, Index, Table of Symbols, Top
@c @appendix Glossary
@appendix 用語集
@cindex glossary
@cindex 用語集

@table @asis
@c @item Backus-Naur Form (BNF)
@item Backus-Naur Form（BNF）（バッカス-ナウア記法）
@c Formal method of specifying context-free grammars.  BNF was first used
@c in the @cite{ALGOL-60} report, 1963.
@c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
@c
文脈自由文法を形式的に表現する方法です。
BNFは、1963年の報告@cite{ALGOL-60}で初めて使われました。
@xref{Language and Grammar, ,Languages and Context-Free Grammars}。

@c @item Context-free grammars
@item Context-free grammars（文脈自由文法）
@c Grammars specified as rules that can be applied regardless of context.
@c Thus, if there is a rule which says that an integer can be used as an
@c expression, integers are allowed @emph{anywhere} an expression is
@c permitted.
@c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
@c
文脈に関係なく適用される規則によって定められる文法です。
したがって、もし、整数は式として使われてもよいという規則があれば、
式が許される@emph{あらゆる場所で}整数の利用が許されます。
@xref{Language and Grammar, ,Languages and Context-Free Grammars}。

@c @item Dynamic allocation
@item Dynamic allocation（動的割り当て）
@c Allocation of memory that occurs during execution, rather than at
@c compile time or on entry to a function.
@c
プログラムをコンパイルするときでも、関数の実行を始めるときでもなく、
実行の途中でメモリを割り当てることです。

@c @item Empty string
@item Empty string（空文字列）
@c Analogous to the empty set in set theory, the empty string is a
@c character string of length zero.
@c
集合論での空集合と同様に、空文字列とは長さが0の文字列です。

@c @item Finite-state stack machine
@item Finite-state stack machine（有限状態スタック機械）
@c A ``machine'' that has discrete states in which it is said to exist at
@c each instant in time.  As input to the machine is processed, the
@c machine moves from state to state as specified by the logic of the
@c machine.  In the case of the parser, the input is the language being
@c parsed, and the states correspond to various stages in the grammar
@c rules.
@c @xref{Algorithm, ,The Bison Parser Algorithm }.
@c
その完全な状態が、各瞬間での状態で記述される「機械」です。
機械への入力が処理されると、機械の論理に応じて、
機械の状態が別の状態に変わります。
本書では、入力とは構文解析されている言語で、
状態とは文法規則のさまざまな段階です。
@xref{Algorithm, ,The Bison Parser Algorithm }。

@c @item Grouping
@item Grouping（グループ）
@c A language construct that is (in general) grammatically divisible;
@c for example, `expression' or `declaration' in C.  
@c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
@c
言語の構成要素で、（一般的に）文法的に分割可能なのもです。
たとえば、C言語の「式」や「宣言」です。
@xref{Language and Grammar, ,Languages and Context-Free Grammars}。

@c @item Infix operator
@item Infix operator（中間記法演算子）
@c An arithmetic operator that is placed between the operands on which it
@c performs some operation.
@c
演算の対象となるオペランドの中間に置かれる算術演算子です。

@c @item Input stream
@item Input stream（入力ストリーム）
@c A continuous flow of data between devices or programs.
@c
入出力装置またはプログラムの間での、連続的なデータの流れです。

@c @item Language construct
@item Language construct（言語構文）
@c One of the typical usage schemas of the language.  For example, one of
@c the constructs of the C language is the @code{if} statement.
@c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
@c
言語の概要を示す典型的な方法の1つです。
たとえば、C言語の構文の1つは@code{if}文です。
@xref{Language and Grammar, ,Languages and Context-Free Grammars}。

@c @item Left associativity
@item Left associativity（左結合性）
@c Operators having left associativity are analyzed from left to right:
@c @samp{a+b+c} first computes @samp{a+b} and then combines with
@c @samp{c}.
@c @xref{Precedence, ,Operator Precedence}.
@c
左結合性を持つ演算子は、左から右に向かって構文解析されます。
たとえば、@samp{a+b+c}では、まず@samp{a+b}が計算され、
次に@samp{c}との和が計算されます。
@xref{Precedence, ,Operator Precedence}。

@c @item Left recursion
@item Left recursion（左再帰）
@c A rule whose result symbol is also its first component symbol;
@c for example, @samp{expseq1 : expseq1 ',' exp;}.
@c @xref{Recursion, ,Recursive Rules}.
@c
結果の記号が構成要素の最初の記号と等しいような規則です。
たとえば、@samp{expseq1 : expseq1 ',' exp;}が左再帰です。
@xref{Recursion, ,Recursive Rules}。

@c @item Left-to-right parsing
@item Left-to-right parsing（LR構文解析）
@c Parsing a sentence of a language by analyzing it token by token from
@c left to right.
@c @xref{Algorithm, ,The Bison Parser Algorithm }.
@c
左側から右側に向かって、トークンを次々に解析していくような、
言語の構文解析方法です。
@xref{Algorithm, ,The Bison Parser Algorithm }。

@c @item Lexical analyzer (scanner)
@item Lexical analyzer（scanner）（字句解析器）
@c A function that reads an input stream and returns tokens one by one.
@c @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}.
@c
入力ストリームを読んで、トークンを1つずつ返す関数です。
@xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。

@c @item Lexical tie-in
@item Lexical tie-in（字句解析結び付き）
@c A flag, set by actions in the grammar rules, which alters the way
@c tokens are parsed.
文法規則によって設定されるフラグが、トークンが字句解析される方法に
影響することです。
@c @xref{Lexical Tie-ins}.
@xref{Lexical Tie-ins}。

@c @item Literal string token
@item Literal string token（リテラル文字列トークン）
@c A token which constists of two or more fixed characters.
@c @xref{Symbols}.
@c
2文字以上の決まった文字列からなるトークンです。
@xref{Symbols}。

@c @item Look-ahead token
@item Look-ahead token（先読みトークン）
@c A token already read but not yet shifted.
@c @xref{Look-Ahead, ,Look-Ahead Tokens}.
@c
すでに読み込まれていて、シフトされていないトークンです。
@xref{Look-Ahead, ,Look-Ahead Tokens}。

@item LALR(1)
@c The class of context-free grammars that Bison (like most other parser
@c generators) can handle; a subset of LR(1).
@c @xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}.
@c
Bison（または似ているほとんどの構文解析器）によって扱える、
文脈自由文法の一部分で、LR(1)の部分集合です。
@xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}。

@item LR(1)
@c The class of context-free grammars in which at most one token of
@c look-ahead is needed to disambiguate the parsing of any piece of input.
@c
任意の入力のあいまいでない構文解析に対して、
単に1個の先読みトークンを必要とするような、
文脈自由文法の一部分です。

@c @item Nonterminal symbol
@item Nonterminal symbol（非終端記号）
@c A grammar symbol standing for a grammatical construct that can
@c be expressed through rules in terms of smaller constructs; in other
@c words, a construct that is not a token.
@c @xref{Symbols}.
@c
文法的構成要素を表す文法記号で、文法規則によってより小さな構成要素に
分解できるものです。言い換えると、トークンでない構成要素です。
@xref{Symbols}。

@c @item Parse error
@item Parse error（構文エラー）
@c An error encountered during parsing of an input stream due to invalid
@c syntax.
@c @xref{Error Recovery}.
@c
入力ストリームを構文解析しているときに、誤った文法によって発生するエラーです。
@xref{Error Recovery}。

@item Parser（構文解析器）
@c A function that recognizes valid sentences of a language by analyzing
@c the syntax structure of a set of tokens passed to it from a lexical
@c analyzer.
字句解析器から渡されたトークンの集合の文法的構造を解析して、
言語の有効な文を認識する関数です。

@c @item Postfix operator
@item Postfix operator（後置演算子）
@c An arithmetic operator that is placed after the operands upon which it
@c performs some operation.
演算の対象のオペランドの後に置かれる算術演算子です。

@c @item Reduction
@item Reduction（還元）
@c Replacing a string of nonterminals and/or terminals with a single
@c nonterminal, according to a grammar rule.
@c @xref{Algorithm, ,The Bison Parser Algorithm }.
@c
文法規則に従って、非終端記号または終端記号の列を、
1個の非終端記号に置き換えることです。
@xref{Algorithm, ,The Bison Parser Algorithm }。

@c @item Reentrant
@item Reentrant（再入可能）
@c A reentrant subprogram is a subprogram which can be in invoked any
@c number of times in parallel, without interference between the various
@c invocations.
@c @xref{Pure Decl, ,A Pure (Reentrant) Parser}.
@c
再入可能な手続きとは、複数の呼び出しの間での相互作用なしに、
並行して任意の数を呼び出せる手続きです。
@footnote{【訳注】ある関数が終了する前に、
その同じ関数を非同期に呼び出してもよいということ。}
@xref{Pure Decl, ,A Pure (Reentrant) Parser}。

@c @item Reverse polish notation
@item Reverse polish notation（逆ポーランド記法）
@c A language in which all operators are postfix operators.
すべての演算子が後置記法演算子であるような言語です。

@c @item Right recursion
@item Right recursion（右再帰）
@c A rule whose result symbol is also its last component symbol;
@c for example, @samp{expseq1: exp ',' expseq1;}.
@c @xref{Recursion, ,Recursive Rules}.
@c
規則の結果の記号が、規則の最後の構成要素と同じ記号であるような規則です。
たとえば、@samp{expseq1: exp ',' expseq1;}は右再帰です。
@xref{Recursion, ,Recursive Rules}.

@c @item Semantics
@item Semantics（意味）
@c In computer languages, the semantics are specified by the actions
@c taken for each instance of the language, i.e., the meaning of
@c each statement.
@c @xref{Semantics, ,Defining Language Semantics}.
@c
計算機言語では、言語の各インスタンスが起こすアクションによって、
意味が指定されます。すなわち、各文の意味です。
@xref{Semantics, ,Defining Language Semantics}。

@c @item Shift
@item Shift（シフト）
@c A parser is said to shift when it makes the choice of analyzing
@c further input from the stream rather than reducing immediately some
@c already-recognized rule.
@c @xref{Algorithm, ,The Bison Parser Algorithm }.
@c
構文解析器がシフトするとは、
すでに認識されているある規則によってただちに還元する代わりに、
ストリームからのさらなる入力を分析することです。
@xref{Algorithm, ,The Bison Parser Algorithm }。

@c @item Single-character literal
@item Single-character literal（1文字リテラル）
@c A single character that is recognized and interpreted as is.
@c @xref{Grammar in Bison, ,From Formal Rules to Bison Input}.
@c
そのままに解釈される@footnote{【訳注】字句解析器によって}1文字です。
@xref{Grammar in Bison, ,From Formal Rules to Bison Input}。

@c @item Start symbol
@item Start symbol（開始記号）
@c The nonterminal symbol that stands for a complete valid utterance in
@c the language being parsed.  The start symbol is usually listed as the
@c first nonterminal symbol in a language specification.  
@c @xref{Start Decl, ,The Start-Symbol}.
@c
構文解析された有効な言語の全体を表す非終端記号です。
通常、言語仕様に書かれた最初の非終端記号です。
@xref{Start Decl, ,The Start-Symbol}。

@c @item Symbol table
@item Symbol table（記号表）
@c A data structure where symbol names and associated data are stored
@c during parsing to allow for recognition and use of existing
@c information in repeated uses of a symbol.
@c @xref{Multi-function Calc}.
@c
繰り返し使われる記号の情報を認識して使うために、
構文解析の途中で、記号の名前と関連する情報を記憶するデータ構造です。
@xref{Multi-function Calc}。

@c @item Token
@item Token（トークン）
@c A basic, grammatically indivisible unit of a language.  The symbol
@c that describes a token in the grammar is a terminal symbol.
@c The input of the Bison parser is a stream of tokens which comes from
@c the lexical analyzer.
@c @xref{Symbols}.
@c
言語の、基本的で、文法的に分割できない単位です。
文法の中のトークンを記述する記号を終端記号といいます。
Bison構文解析器の入力は、字句解析器からの、
トークンの流れです。
@xref{Symbols}。

@c @item Terminal symbol
@item Terminal symbol（終端記号）
@c A grammar symbol that has no rules in the grammar and therefore
@c is grammatically indivisible.  The piece of text it represents
@c is a token.
@c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
@c
文法規則を持たず、したがって文法的に分割できない文法記号です。
これが表す文字の集まりをトークンといいます。
@xref{Language and Grammar, ,Languages and Context-Free Grammars}。
@ignore
この行を含む3行は info ファイル作成時のエラーを回避するために挿入（編集担当）
@end ignore
@end table


@c =====================================================================
@node Index,  , Glossary, Top
@c @unnumbered Index
@unnumbered 索引

@printindex cp

@contents

@bye




@c old menu

* Introduction::
* Conditions::
* Copying::           The GNU General Public License says
                        how you can copy and share Bison

Tutorial sections:
* Concepts::          Basic concepts for understanding Bison.
* Examples::          Three simple explained examples of using Bison.

Reference sections:
* Grammar File::      Writing Bison declarations and rules.
* Interface::         C-language interface to the parser function @code{yyparse}.
* Algorithm::         How the Bison parser works at run-time.
* Error Recovery::    Writing rules for error recovery.
* Context Dependency::What to do if your language syntax is too
                        messy for Bison to handle straightforwardly.
* Debugging::         Debugging Bison parsers that parse wrong.
* Invocation::        How to run Bison (to produce the parser source file).
* Table of Symbols::  All the keywords of the Bison language are explained.
* Glossary::          Basic concepts are explained.
* Index::             Cross-references to the text.



