File:  [Local Repository] / gnujdoc / bison-1.25 / bison-ja.texinfo
Revision 1.3: download - view: text, annotated - select for diffs
Fri Jun 3 15:13:02 2005 UTC (15 years, 5 months ago) by futoshi
Branches: MAIN
CVS tags: HEAD
bison: commnet out one @footnote
gdb-ja: fix umbaranced @end ifclear
remote-ja: replace one @var to @samp

    1: \input texinfo @c -*-texinfo-*-
    2: @c =============================================================
    3: @c = 翻 訳: 石川直太@慶應義塾
    4: @c = ただし、GPLに関しては引地美恵子(mieko@gnu.org)の管理して
    5: @c = いる日本語訳(FSFの指示に従って弁護士のレビューを経たもの)
    6: @c = を用いた。
    7: @c =============================================================
    8: @c
    9: @c to print this file:
   10: @c	jtex bison.texi
   11: @c	texindex bison.cp
   12: @c	jtex bison.texi
   13: @c
   14: @comment %**start of header
   15: @setfilename bison-ja.info
   16: @settitle Bison 1.25
   17: @setchapternewpage odd
   18: 
   19: @iftex
   20: @finalout
   21: @end iftex
   22: 
   23: @c SMALL BOOK version   
   24: @c This edition has been formatted so that you can format and print it in
   25: @c the smallbook format. 
   26: @c @smallbook
   27: 
   28: @c next time, consider using @set for edition number, etc...
   29: 
   30: @c Set following if you have the new `shorttitlepage' command
   31: @c @clear shorttitlepage-enabled
   32: @c @set shorttitlepage-enabled
   33: 
   34: @c infoファイル作成のため以下3行を追加(訳者)
   35: @c Following 3 lines are added by naota to make info file.
   36: @ifinfo
   37: @clear shorttitlepage-enabled
   38: @end ifinfo
   39: 
   40: @c ISPELL CHECK: done, 14 Jan 1993 --bob
   41: 
   42: @c Check COPYRIGHT dates.  should be updated in the titlepage, ifinfo
   43: @c titlepage; should NOT be changed in the GPL.  --mew
   44: 
   45: @iftex
   46: @syncodeindex fn cp
   47: @syncodeindex vr cp
   48: @syncodeindex tp cp
   49: @end iftex
   50: @ifinfo
   51: @synindex fn cp
   52: @synindex vr cp
   53: @synindex tp cp
   54: @end ifinfo
   55: @comment %**end of header
   56: 
   57: @ifinfo
   58: This file documents the Bison parser generator.
   59: 
   60: Copyright (C) 1988, 89, 90, 91, 92, 93, 1995 Free Software Foundation, Inc.
   61: 
   62: Permission is granted to make and distribute verbatim copies of
   63: this manual provided the copyright notice and this permission notice
   64: are preserved on all copies.
   65: 
   66: @ignore
   67: Permission is granted to process this file through Tex and print the
   68: results, provided the printed document carries copying permission
   69: notice identical to this one except for the removal of this paragraph
   70: (this paragraph not being relevant to the printed manual).
   71: 
   72: @end ignore
   73: Permission is granted to copy and distribute modified versions of this
   74: manual under the conditions for verbatim copying, provided also that the
   75: sections entitled ``GNU General Public License'' and ``Conditions for
   76: Using Bison'' are included exactly as in the original, and provided that
   77: the entire resulting derived work is distributed under the terms of a
   78: permission notice identical to this one.
   79: 
   80: Permission is granted to copy and distribute translations of this manual
   81: into another language, under the above conditions for modified versions,
   82: except that the sections entitled ``GNU General Public License'',
   83: ``Conditions for Using Bison'' and this permission notice may be
   84: included in translations approved by the Free Software Foundation
   85: instead of in the original English.
   86: @end ifinfo
   87: 
   88: @ifset shorttitlepage-enabled
   89: @shorttitlepage Bison
   90: @end ifset
   91: @titlepage
   92: @c @title Bison
   93: @title Bison入門
   94: @subtitle The YACC-compatible Parser Generator
   95: @c @subtitle YACC互換構文解析器生成ツール
   96: @subtitle November 1995, Bison Version 1.25
   97: 
   98: @author by Charles Donnelly and Richard Stallman
   99: @c 日本語訳:石川直太
  100: 
  101: @page
  102: @vskip 0pt plus 1filll
  103: Copyright @copyright{} 1988, 89, 90, 91, 92, 93, 1995 Free Software
  104: Foundation 
  105: 
  106: @sp 2
  107: Published by the Free Software Foundation @*
  108: 59 Temple Place, Suite 330 @*
  109: Boston, MA  02111-1307  USA @*
  110: Printed copies are available for $15 each.@*
  111: ISBN 1-882114-45-0
  112: 
  113: Permission is granted to make and distribute verbatim copies of
  114: this manual provided the copyright notice and this permission notice
  115: are preserved on all copies.
  116: 
  117: @ignore
  118: Permission is granted to process this file through TeX and print the
  119: results, provided the printed document carries copying permission
  120: notice identical to this one except for the removal of this paragraph
  121: (this paragraph not being relevant to the printed manual).
  122: 
  123: @end ignore
  124: Permission is granted to copy and distribute modified versions of this
  125: manual under the conditions for verbatim copying, provided also that the
  126: sections entitled ``GNU General Public License'' and ``Conditions for
  127: Using Bison'' are included exactly as in the original, and provided that
  128: the entire resulting derived work is distributed under the terms of a
  129: permission notice identical to this one.
  130: 
  131: Permission is granted to copy and distribute translations of this manual
  132: into another language, under the above conditions for modified versions,
  133: except that the sections entitled ``GNU General Public License'',
  134: ``Conditions for Using Bison'' and this permission notice may be
  135: included in translations approved by the Free Software Foundation
  136: instead of in the original English.
  137: @sp 2
  138: Cover art by Etienne Suvasa.
  139: @end titlepage
  140: @page
  141: 
  142: 
  143: @c =====================================================================
  144: @node Top, Introduction, (dir), (dir)
  145: 
  146: @ifinfo
  147: This manual documents version 1.25 of Bison.
  148: @end ifinfo
  149: 
  150: @menu
  151: * Introduction::      
  152: * Conditions::        
  153: * Copying::           The GNU General Public License says
  154:                         how you can copy and share Bison
  155: 
  156: Tutorial sections:
  157: * Concepts::          Basic concepts for understanding Bison.
  158: * Examples::          Three simple explained examples of using Bison.
  159: 
  160: Reference sections:
  161: * Grammar File::      Writing Bison declarations and rules.
  162: * Interface::         C-language interface to the parser function @code{yyparse}.
  163: * Algorithm::         How the Bison parser works at run-time.
  164: * Error Recovery::    Writing rules for error recovery.
  165: * Context Dependency::  What to do if your language syntax is too
  166:                         messy for Bison to handle straightforwardly.
  167: * Debugging::         Debugging Bison parsers that parse wrong.
  168: * Invocation::        How to run Bison (to produce the parser source file).
  169: * Table of Symbols::  All the keywords of the Bison language are explained.
  170: * Glossary::          Basic concepts are explained.
  171: * Index::             Cross-references to the text.
  172: 
  173:  --- The Detailed Node Listing ---
  174: 
  175: Bisonの概念
  176: 
  177: * Language and Grammar::  Languages and context-free grammars,
  178:                             as mathematical ideas.
  179: * Grammar in Bison::  How we represent grammars for Bison's sake.
  180: * Semantic Values::   Each token or syntactic grouping can have
  181:                         a semantic value (the value of an integer,
  182:                         the name of an identifier, etc.).
  183: * Semantic Actions::  Each rule can have an action containing C code.
  184: * Bison Parser::      What are Bison's input and output,
  185:                         how is the output used?
  186: * Stages::            Stages in writing and running Bison grammars.
  187: * Grammar Layout::    Overall structure of a Bison grammar file.
  188: 
  189:   190: 
  191: * RPN Calc::          Reverse polish notation calculator;
  192:                         a first example with no operator precedence.
  193: * Infix Calc::        Infix (algebraic) notation calculator.
  194:                         Operator precedence is introduced.
  195: * Simple Error Recovery::  Continuing after syntax errors.
  196: * Multi-function Calc::  Calculator with memory and trig functions.
  197:                            It uses multiple data-types for semantic values.
  198: * Exercises::         Ideas for improving the multi-function calculator.
  199: 
  200: 逆ポーランド記法電卓
  201: 
  202: * Decls: Rpcalc Decls.  Bison and C declarations for rpcalc.
  203: * Rules: Rpcalc Rules.  Grammar Rules for rpcalc, with explanation.
  204: * Lexer: Rpcalc Lexer.  The lexical analyzer.
  205: * Main: Rpcalc Main.    The controlling function.
  206: * Error: Rpcalc Error.  The error reporting function.
  207: * Gen: Rpcalc Gen.      Running Bison on the grammar file.
  208: * Comp: Rpcalc Compile. Run the C compiler on the output code.
  209: 
  210: @code{rpcalc}のための文法規則
  211: 
  212: * Rpcalc Input::      
  213: * Rpcalc Line::       
  214: * Rpcalc Expr::       
  215: 
  216: 多機能電卓:@code{mfcalc}
  217: 
  218: * Decl: Mfcalc Decl.      Bison declarations for multi-function calculator.
  219: * Rules: Mfcalc Rules.    Grammar rules for the calculator.
  220: * Symtab: Mfcalc Symtab.  Symbol table management subroutines.
  221: 
  222: Bison文法ファイル
  223: 
  224: * Grammar Outline::   Overall layout of the grammar file.
  225: * Symbols::           Terminal and nonterminal symbols.
  226: * Rules::             How to write grammar rules.
  227: * Recursion::         Writing recursive rules.
  228: * Semantics::         Semantic values and actions.
  229: * Declarations::      All kinds of Bison declarations are described here.
  230: * Multiple Parsers::  Putting more than one Bison parser in one program.
  231: 
  232: Bison文法の概要
  233: 
  234: * C Declarations::    Syntax and usage of the C declarations section.
  235: * Bison Declarations::  Syntax and usage of the Bison declarations section.
  236: * Grammar Rules::     Syntax and usage of the grammar rules section.
  237: * C Code::            Syntax and usage of the additional C code section.
  238: 
  239: 言語の意味の定義
  240: 
  241: * Value Type::        Specifying one data type for all semantic values.
  242: * Multiple Types::    Specifying several alternative data types.
  243: * Actions::           An action is the semantic definition of a grammar rule.
  244: * Action Types::      Specifying data types for actions to operate on.
  245: * Mid-Rule Actions::  Most actions go at the end of a rule.
  246:                       This says when, why and how to use the exceptional
  247:                         action in the middle of a rule.
  248: 
  249: Bison宣言
  250: 
  251: * Token Decl::        Declaring terminal symbols.
  252: * Precedence Decl::   Declaring terminals with precedence and associativity.
  253: * Union Decl::        Declaring the set of all semantic value types.
  254: * Type Decl::         Declaring the choice of type for a nonterminal symbol.
  255: * Expect Decl::       Suppressing warnings about shift/reduce conflicts.
  256: * Start Decl::        Specifying the start symbol.
  257: * Pure Decl::         Requesting a reentrant parser.
  258: * Decl Summary::      Table of all Bison declarations.
  259: 
  260: 構文解析器のC言語インターフェイス
  261: 
  262: * Parser Function::   How to call @code{yyparse} and what it returns.
  263: * Lexical::           You must supply a function @code{yylex} 
  264:                         which reads tokens.
  265: * Error Reporting::   You must supply a function @code{yyerror}.
  266: * Action Features::   Special features for use in actions.
  267: 
  268: 字句解析器関数@code{yylex}
  269: 
  270: * Calling Convention::  How @code{yyparse} calls @code{yylex}.
  271: * Token Values::      How @code{yylex} must return the semantic value
  272:                         of the token it has read.
  273: * Token Positions::   How @code{yylex} must return the text position
  274:                         (line number, etc.) of the token, if the
  275:                         actions want that.
  276: * Pure Calling::      How the calling convention differs
  277:                         in a pure parser (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).
  278: 
  279: Bison構文解析器のアルゴリズム
  280: 
  281: * Look-Ahead::        Parser looks one token ahead when deciding what to do.
  282: * Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
  283: * Precedence::        Operator precedence works by resolving conflicts.
  284: * Contextual Precedence::  When an operator's precedence depends on context.
  285: * Parser States::     The parser is a finite-state-machine with stack.
  286: * Reduce/Reduce::     When two rules are applicable in the same situation.
  287: * Mystery Conflicts::  Reduce/reduce conflicts that look unjustified.
  288: * Stack Overflow::    What happens when stack gets full.  How to avoid it.
  289: 
  290: 演算子の優先順位
  291: 
  292: * Why Precedence::    An example showing why precedence is needed.
  293: * Using Precedence::  How to specify precedence in Bison grammars.
  294: * Precedence Examples::  How these features are used in the previous example.
  295: * How Precedence::    How they work.
  296: 
  297: 文脈依存性の処理
  298: 
  299: * Semantic Tokens::   Token parsing can depend on the semantic context.
  300: * Lexical Tie-ins::   Token parsing can depend on the syntactic context.
  301: * Tie-in Recovery::   Lexical tie-ins have implications for how
  302:                         error recovery rules must be written.
  303: 
  304: Bisonの実行
  305: 
  306: * Bison Options::     All the options described in detail, 
  307: 			in alphabetical order by short options.
  308: * Option Cross Key::  Alphabetical list of long options.
  309: * VMS Invocation::    Bison command syntax on VMS.
  310: @end menu
  311: 
  312: @c =====================================================================
  313: @node Introduction, Conditions, Top, Top
  314: @c @unnumbered Introduction
  315: @unnumbered まえがき
  316: @cindex introduction
  317: @cindex まえがき
  318: 
  319: @c @dfn{Bison} is a general-purpose parser generator that converts a
  320: @c grammar description for an LALR(1) context-free grammar into a C
  321: @c program to parse that grammar.  Once you are proficient with Bison,
  322: @c you may use it to develop a wide range of language parsers, from those
  323: @c used in simple desk calculators to complex programming languages.
  324: 
  325: Bisonは、LALR(1)文脈自由文法の文法定義を、
  326: その文法を解析するためのCで書かれたプログラムに変換する、
  327: 汎用の構文解析器生成ツールです。
  328: あなたがBisonに熟練すれば、
  329: 簡単な電卓から複雑なプログラミング言語まで、
  330: 広い範囲の言語解析器を開発できるようになるでしょう。
  331: 
  332: @c Bison is upward compatible with Yacc: all properly-written Yacc grammars
  333: @c ought to work with Bison with no change.  Anyone familiar with Yacc
  334: @c should be able to use Bison with little trouble.  You need to be fluent in
  335: @c C programming in order to use Bison or to understand this manual.
  336: 
  337: BisonはYaccの上位互換です。
  338: 正しく書かれたすべてのYacc文法を、変更なくBisonで処理できます。
  339: Yaccに親しんでいるすべての人は、ちょっと考えるだけで、
  340: Bisonを使えるようになるでしょう。
  341: Bisonを使い、本書を理解するためには、
  342: C言語に精通している必要があります。
  343: 
  344: @c We begin with tutorial chapters that explain the basic concepts of using
  345: @c Bison and show three explained examples, each building on the last.  If you
  346: @c don't know Bison or Yacc, start by reading these chapters.  Reference
  347: @c chapters follow which describe specific aspects of Bison in detail.
  348: 
  349: 1章と2章は入門の章です。1章では、Bisonを使うための基本的な概念を説明し、
  350: 2章では3つの具体例を示します。
  351: BisonやYaccを知らない方は、
  352: 1章から読みはじめてください。
  353: 3章以降では、Bisonの仕様を詳細に解説します。
  354: 
  355: @c Bison was written primarily by Robert Corbett; Richard Stallman made it
  356: @c Yacc-compatible.  Wilfred Hansen of Carnegie Mellon University added
  357: @c multicharacter string literals and other features.
  358: 
  359: Bisonは、最初にRobert Corbettによって開発され、
  360: Richard StallmanがYacc互換にしました。
  361: カーネギーメロン大学のWilfred Hansenが、
  362: 文字列リテラル@footnote{【訳注】2文字以上の文字列、たとえば@samp{==}を、
  363: トークン名に使う機能。}といくつかの機能を追加しました。
  364: 
  365: @c This edition corresponds to version 1.25 of Bison.
  366: 本書は、Bisonのバージョン1.25に基づいています。
  367: 
  368: @unnumberedsec 日本語訳にあたって
  369: 
  370: 本書は、株式会社アスキーの
  371: 支援を受けて、慶應義塾の石川直太
  372: (@samp{naota@@sfc.keio.ac.jp、http://www.sfc.keio.ac.jp/~naota/})
  373: が翻訳しました。
  374: 
  375: なお、「GNU一般公有使用許諾書」の日本語訳については、
  376: 引地さんのところの日本語訳を使わせていただいたことを
  377: ここに記して感謝いたします。
  378: 
  379: 日本語訳したtexinfoファイルは、
  380: @samp{http://www.ascii.co.jp/pub/GNU/bison-1.25-man-jp.tgz}
  381: にあります。コマンドtexi2dviなどでdviファイルを生成したり、GNU Emacsでinfoファイルへ変換したりできます。
  382: 
  383: @c =====================================================================
  384: @node Conditions, Copying, Introduction, Top
  385: @c @unnumbered Conditions for Using Bison
  386: @unnumbered Bisonの利用条件
  387: 
  388: @c As of Bison version 1.24, we have changed the distribution terms for
  389: @c @code{yyparse} to permit using Bison's output in non-free programs.
  390: @c Formerly, Bison parsers could be used only in programs that were free
  391: @c software.
  392: 
  393: Bisonバージョン1.24において、フリーでないプログラムへのBisonの出力の
  394: 利用を許可するために、@code{yyparse}の配布条件を変えました。
  395: それまでは、Bisonによって生成された構文解析器は、
  396: フリーソフトウェアのプログラム中でのみ、利用可能でした。
  397: 
  398: @c The other GNU programming tools, such as the GNU C compiler, have never
  399: @c had such a requirement.  They could always be used for non-free
  400: @c software.  The reason Bison was different was not due to a special
  401: @c policy decision; it resulted from applying the usual General Public
  402: @c License to all of the Bison source code.
  403: 
  404: GNU Cコンパイラなど他のGNUプログランミングツールには、
  405: このような制限がありません。
  406: それらは、いつでも、フリーでないソフトウェアの開発に利用できます。
  407: Bisonの利用条件が異なっていた理由は、特別な政治的判断によるものではありません。
  408: BisonのすべてのソースコードにGPLを適用した結果です。
  409: 
  410: @c The output of the Bison utility---the Bison parser file---contains a
  411: @c verbatim copy of a sizable piece of Bison, which is the code for the
  412: @c @code{yyparse} function.  (The actions from your grammar are inserted
  413: @c into this function at one point, but the rest of the function is not
  414: @c changed.)  When we applied the GPL terms to the code for @code{yyparse},
  415: @c the effect was to restrict the use of Bison output to free software.
  416: 
  417: Bisonの出力であるBison構文解析器ファイルには、
  418: @code{yyparse}関数のためのコードである、
  419: かなりの量のBisonのソースコードの一部分が、そのまま含まれます
  420: (あなたが定義した文法によるアクションは、
  421: この関数の1か所に挿入されるだけで、残りの関数は変わりません)。
  422: われわれFSFが@code{yyparse}のコードにGPLを適用した結果、
  423: Bisonの出力をフリーソフトウェアのみに利用するという制約ができたのです。
  424: 
  425: @c We didn't change the terms because of sympathy for people who want to
  426: @c make software proprietary.  @strong{Software should be free.}  But we
  427: @c concluded that limiting Bison's use to free software was doing little to
  428: @c encourage people to make other software free.  So we decided to make the
  429: @c practical conditions for using Bison match the practical conditions for
  430: @c using the other GNU tools.
  431: 
  432: ソフトウェアを専売しようとする人々への思いやりによって、
  433: われわれが条件を変えることはありませんでした。
  434: @strong{ソフトウェアはフリーであるべきです。}
  435: しかし、われわれは、Bisonの利用をフリーソフトウェアに限定したことは、
  436: 他のソフトウェアをフリーにしようとする人々を勇気づけるために、
  437: 少なからず役立っただろうと、結論を下しました。
  438: そこで、われわれは、その他のGNUツールの現実的な利用条件に合わせて、
  439: Bisonの現実的な利用条件を決定することにしました。
  440: 
  441: 
  442: @c =============================================================
  443: @c = <using 引地さんが管理するGPLの日本語訳>
  444: @c =============================================================
  445: @node Copying, Concepts, Conditions, Top
  446: @c @unnumbered GNU GENERAL PUBLIC LICENSE
  447: @c @center Version 2, June 1991
  448: @unnumbered GNU一般公有使用許諾書
  449: @center 1991年6月 バージョン2.0 
  450: 
  451: @display
  452: Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
  453: @c 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  454: 675 Mass Ave, Cambridge, MA 02139, USA @footnote{【注意】
  455: 現在、このバージョン2の発行者(FSF)住所は、正式に新しい住所の @*
  456:  59 Temple Place, Suite 330, Boston, MA 02111-1307, USA @*
  457: に変わっている。}
  458: @ifinfo
  459: 【注意】 現在、このバージョン2の発行者(FSF)住所は、正式に新しい住所の
  460: 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA に変わっている。
  461: @end ifinfo
  462: 
  463: @c Everyone is permitted to copy and distribute verbatim copies
  464: @c of this license document, but changing it is not allowed.
  465: 何人も、以下の内容を変更しないでそのまま複写する場合に限り、
  466: 本使用許諾書を複製したり頒布することができます。
  467: @end display
  468: 
  469: @c @unnumberedsec Preamble
  470: @unnumberedsec はじめに
  471: 
  472: @c   The licenses for most software are designed to take away your
  473: @c freedom to share and change it.  By contrast, the GNU General Public
  474: @c License is intended to guarantee your freedom to share and change free
  475: @c software---to make sure the software is free for all its users.  This
  476: @c General Public License applies to most of the Free Software
  477: @c Foundation's software and to any other program whose authors commit to
  478: @c using it.  (Some other Free Software Foundation software is covered by
  479: @c the GNU Library General Public License instead.)  You can apply it to
  480: @c your programs, too.
  481:  ほとんどのソフトウェアの使用許諾は、ソフトウェアを共有し、
  482: 変更するユーザの自由を奪うことを意図しています。
  483: それに対して、我々のGNU一般公有使用許諾は、
  484: フリー・ソフトウェアを共有したり変更する自由をユーザに保証するためのもの、
  485: 即ちフリー・ソフトウェアがそのユーザ全てにとって
  486: フリーであることを保証するためのものです。
  487: 本使用許諾は、Free Software Foundationのほとんど全てのソフトウェアに
  488: 適用されるだけでなく、
  489: プログラムの作成者が本使用許諾に依るとした場合のそのプログラムにも
  490: 適用することができます。
  491: (その他の Free Software Foundation のソフトウェアのいくつかは、
  492: 本許諾書ではなく、GNUライブラリ一般公有使用許諾で保護されます。)
  493: あなたは自分のプログラムにもこれを適用できます。
  494: 
  495: @c   When we speak of free software, we are referring to freedom, not
  496: @c price.  Our General Public Licenses are designed to make sure that you
  497: @c have the freedom to distribute copies of free software (and charge for
  498: @c this service if you wish), that you receive source code or can get it
  499: @c if you want it, that you can change the software or use pieces of it
  500: @c in new free programs; and that you know you can do these things.
  501:  我々がフリー・ソフトウェアについて言う場合は
  502: 自由のことに言及しているのであって、価格のことではありません。
  503: 我々の一般公有使用許諾の各条項は、次の事柄を確実に実現することを
  504: 目的として立案されています。
  505: @itemize @bullet
  506: @item
  507: フリー・ソフトウェアの複製物を自由に頒布できること
  508: (そして、望むならあなたのこのサービスに対して対価を請求できること)。
  509: @item
  510: ソース・コードを実際に受け取るか、あるいは、
  511: 希望しさえすればそれを入手することが可能であること。
  512: @item
  513: 入手したソフトウェアを変更したり、
  514: 新しいフリー・プログラムの一部として使用できること。
  515: @item
  516: 以上の各内容を行なうことができるということをユーザ自身が知っていること。
  517: @end itemize
  518: 
  519: @c   To protect your rights, we need to make restrictions that forbid
  520: @c anyone to deny you these rights or to ask you to surrender the rights.
  521: @c These restrictions translate to certain responsibilities for you if you
  522: @c distribute copies of the software, or if you modify it.
  523:  このようなユーザの権利を守るために、我々は、
  524: 何人もこれらの権利を否定したり、あるいは放棄するように
  525: ユーザに求めることはできないという制限条項を設ける必要があります。
  526: これらの制限条項は、ユーザが、フリー・ソフトウェアの複製物を
  527: 頒布したり変更しようとする場合には、そのユーザ自身が守るべき義務ともなります。
  528: 
  529: @c   For example, if you distribute copies of such a program, whether
  530: @c gratis or for a fee, you must give the recipients all the rights that
  531: @c you have.  You must make sure that they, too, receive or can get the
  532: @c source code.  And you must show them these terms so they know their
  533: @c rights.
  534:  例えば、あなたがフリー・ソフトウェアの複製物を頒布する場合、
  535: 有償か無償かにかかわらず、
  536: あなたは自分の持っている権利を全て相手に与えなければなりません。
  537: あなたは、相手もまたソース・コードを受け取ったり入手できるということを
  538: 認めなければなりません。
  539: さらにあなたは、彼らが自分たちの権利を知るように、
  540: これらの条項を知らしめなければなりません。
  541: 
  542: @c   We protect your rights with two steps: (1) copyright the software, and
  543: @c (2) offer you this license which gives you legal permission to copy,
  544: @c distribute and/or modify the software.
  545:  我々は次の2つの方法でユーザの権利を守ります。
  546: (1)ソフトウェアに著作権を主張し、
  547: (2)本使用許諾の条項の下で
  548: ソフトウェアを複製・頒布・変更する権利をユーザに与えます。
  549: 
  550: @c   Also, for each author's protection and ours, we want to make certain
  551: @c that everyone understands that there is no warranty for this free
  552: @c software.  If the software is modified by someone else and passed on, we
  553: @c want its recipients to know that what they have is not the original, so
  554: @c that any problems introduced by others will not reflect on the original
  555: @c authors' reputations.
  556:  また、各作成者や我々自身を守るために、
  557: 本フリー・ソフトウェアが無保証であることを
  558: 全ての人々が了解している必要があります。
  559: さらに、他の誰かによって変更されたソフトウェアが頒布された場合、
  560: 受領者はそのソフトウェアがオリジナル・バージョンではないということを
  561: 知らされる必要があります。
  562: それは、他人の関与によって原開発者に対する評価が
  563: 影響されないようにするためです。
  564: 
  565: @c   Finally, any free program is threatened constantly by software
  566: @c patents.  We wish to avoid the danger that redistributors of a free
  567: @c program will individually obtain patent licenses, in effect making the
  568: @c program proprietary.  To prevent this, we have made it clear that any
  569: @c patent must be licensed for everyone's free use or not licensed at all.
  570:  最後に、どのフリー・プログラムもソフトウェア特許に絶えず脅かされています。
  571: 我々は、フリー・プログラムの再頒布者が個人的に特許権を取得し、
  572: 事実上そのプログラムを自分の財産にしてしまうという危険を
  573: 避けたいと願っています。
  574: これを防ぐために我々は、いずれの特許も、
  575: 誰でも自由に使用できるように使用許諾されるべきか、
  576: あるいは何人に対しても全く使用させないかの、
  577: いずれかにすべきであることを明らかにしてきました。
  578: 
  579: @c   The precise terms and conditions for copying, distribution and
  580: @c modification follow.
  581:  複写・頒布・変更に対する正確な条項と条件を次に示します。
  582: 
  583: @iftex
  584: @c @unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  585: @unnumberedsec GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件
  586: @end iftex
  587: @ifinfo
  588: @c @center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  589: @center GNU一般公有使用許諾の下での複製、頒布、変更に関する条項と条件
  590: @end ifinfo
  591: 
  592: @enumerate 1
  593: @item
  594: @c This License applies to any program or other work which contains
  595: @c a notice placed by the copyright holder saying it may be distributed
  596: @c under the terms of this General Public License.  The ``Program'', below,
  597: @c refers to any such program or work, and a ``work based on the Program''
  598: @c means either the Program or any derivative work under copyright law:
  599: @c that is to say, a work containing the Program or a portion of it,
  600: @c either verbatim or with modifications and/or translated into another
  601: @c language.  (Hereinafter, translation is included without limitation in
  602: @c the term ``modification''.)  Each licensee is addressed as ``you''.
  603: 本使用許諾は、本一般公有使用許諾の各条項に従って頒布されるという
  604: 著作権者からの告知文が表示されているプログラムやその他の作成物に適用されます。
  605: 以下において「プログラム」とは、そのようなプログラムや作成物を指すものとし、
  606: また、「プログラム生成物」とは、上述した「プログラム」自身、または、
  607: 著作権法下における全ての派生物;すなわち、その「プログラム」の全部又は一部を、
  608: そのまま又は変更して、且つ/又は他の言語に変換して、
  609: 内部に組み込んだ作成物を意味します。
  610: (以下、言語変換は「変更」という用語の中に無条件に含まれるものとします。)
  611: 本使用許諾によって許諾を受ける者を「あなた」と呼びます。 
  612: 
  613: @c Activities other than copying, distribution and modification are not
  614: @c covered by this License; they are outside its scope.  The act of
  615: @c running the Program is not restricted, and the output from the Program
  616: @c is covered only if its contents constitute a work based on the
  617: @c Program (independent of having been made by running the Program).
  618: @c Whether that is true depends on what the Program does.
  619: 複製、頒布、変更以外の行為は本使用許諾の対象としません。
  620: それらは本使用許諾の範囲外です。
  621: 「プログラム」を実行させる行為に関して制約はありません。
  622: 「プログラム」の出力は、
  623: (「プログラム」を実行させて作成させたかどうかとは無関係に)
  624: その内容が「プログラム生成物」である場合に限り本使用許諾の対象となります。
  625: これが当てはまるかどうかは、「プログラム」が何をするものかに依ります。
  626: 
  627: @item
  628: @c You may copy and distribute verbatim copies of the Program's
  629: @c source code as you receive it, in any medium, provided that you
  630: @c conspicuously and appropriately publish on each copy an appropriate
  631: @c copyright notice and disclaimer of warranty; keep intact all the
  632: @c notices that refer to this License and to the absence of any warranty;
  633: @c and give any other recipients of the Program a copy of this License
  634: @c along with the Program.
  635: あなたは、どのような媒体上へ複製しようとする場合であっても、
  636: 入手した「プログラム」のソース・コードを
  637: そのままの内容で複写した上で適正な著作権表示と保証の放棄を明確、
  638: 且つ適正に付記する場合に限り、複製又は頒布することができます。
  639: その場合、本使用許諾及び無保証に関する記載部分は、
  640: 全て元のままの形で表示してください。
  641: また、「プログラム」の頒布先に対しては、
  642: 「プログラム」と共に本使用許諾書の写しを渡してください。
  643: 
  644: @c You may charge a fee for the physical act of transferring a copy, and
  645: @c you may at your option offer warranty protection in exchange for a fee.
  646: 複製物の引き渡しに要する実費は請求することができます。
  647: また、あなた独自の保証を行なう場合はそれを有償とすることができます。
  648: 
  649: @item
  650: @c You may modify your copy or copies of the Program or any portion
  651: @c of it, thus forming a work based on the Program, and copy and
  652: @c distribute such modifications or work under the terms of Section 1
  653: @c above, provided that you also meet all of these conditions:
  654: 次の各条件を全て満たしている限り、あなたは、
  655: 「プログラム」又はその一部分を変更して「プログラム生成物」とすることができ、
  656: さらに、変更版や右作成物を上記第2項に従って複製又は頒布することもできます。
  657: 
  658: @enumerate a
  659: @item
  660: @c You must cause the modified files to carry prominent notices
  661: @c stating that you changed the files and the date of any change.
  662: ファイルを変更した旨とその変更日とを、変更したファイル上に明確に表示すること。
  663: 
  664: @item
  665: @c You must cause any work that you distribute or publish, that in
  666: @c whole or in part contains or is derived from the Program or any
  667: @c part thereof, to be licensed as a whole at no charge to all third
  668: @c parties under the terms of this License.
  669: 変更したか否かを問わず、凡そ「プログラム」
  670: 又はその一部分を内部に組み込んでいるか
  671: 又はそれから派生した生成物を頒布する場合には、
  672: その全体を本使用許諾の条項に従って第三者へ無償で使用許諾すること。
  673: 
  674: @item
  675: @c If the modified program normally reads commands interactively
  676: @c when run, you must cause it, when started running for such
  677: @c interactive use in the most ordinary way, to print or display an
  678: @c announcement including an appropriate copyright notice and a
  679: @c notice that there is no warranty (or else, saying that you provide
  680: @c a warranty) and that users may redistribute the program under
  681: @c these conditions, and telling the user how to view a copy of this
  682: @c License.  (Exception: if the Program itself is interactive but
  683: @c does not normally print such an announcement, your work based on
  684: @c the Program is not required to print an announcement.)
  685: 変更したプログラムが実行時に通常の対話的な方法で
  686: コマンドを読むようになっているとすれば、
  687: 最も普通の方法で対話的にそのプログラムを実行する時に、
  688: 次の内容を示す文言がプリンタへ印字されるか、或いは画面に表示されること。
  689: @itemize @bullet
  690: @item
  691: 適切な著作権表示。
  692: @item
  693: 無保証であること(あなたが独自に保証する場合は、その旨)。
  694: @item
  695: 頒布を受ける者も、
  696: 本使用許諾と同一の条項に従って「プログラム」を再頒布できること。
  697: @item
  698: 頒布を受ける者が本使用許諾書の写しを参照する方法。
  699: (例外として、「プログラム」自体は対話的であっても起動時の文言を
  700: 通常は印字しないのならば、
  701: あなたの「プログラム生成物」はこのような文言を印字する必要はありません。)
  702: @end itemize
  703: @end enumerate
  704: 
  705: @c These requirements apply to the modified work as a whole.  If
  706: @c identifiable sections of that work are not derived from the Program,
  707: @c and can be reasonably considered independent and separate works in
  708: @c themselves, then this License, and its terms, do not apply to those
  709: @c sections when you distribute them as separate works.  But when you
  710: @c distribute the same sections as part of a whole which is a work based
  711: @c on the Program, the distribution of the whole must be on the terms of
  712: @c this License, whose permissions for other licensees extend to the
  713: @c entire whole, and thus to each and every part regardless of who wrote it.
  714: これらの要件は変更された作成物にも全て適用されます。
  715: その変更版の或る部分が「プログラム」の派生物ではなく、
  716: しかもそれ自体独立で異なる作成物だと合理的に考えられる場合、
  717: あなたがそれらを別の作成物として頒布した時は、
  718: 本使用許諾とその条項はそれらの部分には適用されません。
  719: しかし、それらを「プログラム生成物」の一部として頒布する場合は、
  720: 全体が本使用許諾の条項に従って頒布されなければならず、
  721: 使用許諾を受ける他の全ての者に対する許諾も
  722: プログラム全体にわたって与えられなければならず、
  723: 結果として、誰が書いたかにかかわらず、
  724: 全ての部分に本使用許諾が適用されなければなりません。
  725: 
  726: @c Thus, it is not the intent of this section to claim rights or contest
  727: @c your rights to work written entirely by you; rather, the intent is to
  728: @c exercise the right to control the distribution of derivative or
  729: @c collective works based on the Program.
  730: このように、本条項の意図するところは、
  731: 完全にあなたによって書かれた作成物について、権利を要求したり、
  732: あなたと権利関係を争うことではありません。
  733: むしろその目的は、作成物が「プログラム生成物」
  734: である場合にその派生物や集合物の頒布を規制することにあります。
  735: 
  736: @c In addition, mere aggregation of another work not based on the Program
  737: @c with the Program (or with a work based on the Program) on a volume of
  738: @c a storage or distribution medium does not bring the other work under
  739: @c the scope of this License.
  740: さらに、「プログラム」(又は「プログラム生成物」)と
  741: 「プログラム生成物」とはならない他のプログラムとを、
  742: 単に保管や頒布のために同一の媒体上にまとめて記録したとしても、
  743: 本使用許諾は他のプログラムには適用されません。
  744: 
  745: @item
  746: @c You may copy and distribute the Program (or a work based on it,
  747: @c under Section 2) in object code or executable form under the terms of
  748: @c Sections 1 and 2 above provided that you also do one of the following:
  749: あなたは、以下のうちいずれか1つを満たす限り、
  750: 上記第2項及び第3項に従って「プログラム」
  751: (又は、上記第3項で言及している「プログラム生成物」)を
  752: オブジェクト・コード又は実行可能な形式で複製及び頒布することができます。
  753: 
  754: @enumerate a
  755: @item
  756: @c Accompany it with the complete corresponding machine-readable
  757: @c source code, which must be distributed under the terms of Sections
  758: @c 1 and 2 above on a medium customarily used for software interchange; or,
  759: 対応する機械読み取り可能なソース・コード一式を一緒に引き渡すこと。
  760: その場合、そのソース・コードの引き渡しは上記第2項及び第3項に従って、
  761: 通常ソフトウェアの交換に用いられる媒体で行なわれること。
  762: 
  763: @item
  764: @c Accompany it with a written offer, valid for at least three
  765: @c years, to give any third party, for a charge no more than your
  766: @c cost of physically performing source distribution, a complete
  767: @c machine-readable copy of the corresponding source code, to be
  768: @c distributed under the terms of Sections 1 and 2 above on a medium
  769: @c customarily used for software interchange; or,
  770: 少なくとも3年間の有効期間を定め、
  771: 且つその期間内であれば対応する機械読み取り可能なソース・コード一式の複製を、
  772: ソース頒布に関わる実費以上の対価を要求せずに提供する旨、
  773: 及びその場合には上記第2項及び第3項に従って、
  774: 通常ソフトウェアの交換に用いられる媒体で提供される旨を記載した書面を、
  775: 第三者に一緒に引き渡すこと。
  776: 
  777: @item
  778: @c Accompany it with the information you received as to the offer
  779: @c to distribute corresponding source code.  (This alternative is
  780: @c allowed only for noncommercial distribution and only if you
  781: @c received the program in object code or executable form with such
  782: @c an offer, in accord with Subsection b above.)
  783: 対応するソース・コード頒布の申し出に際して、
  784: あなたが得た情報を一緒に引き渡すこと。
  785: (この選択肢は、営利を目的としない頒布であって、
  786: 且つあなたが上記の(b)項に基づいて、
  787: オブジェクト・コード或いは実行可能形式の
  788: プログラムしか入手していない場合に限り適用される選択項目です。)
  789: @end enumerate
  790: 
  791: @c The source code for a work means the preferred form of the work for
  792: @c making modifications to it.  For an executable work, complete source
  793: @c code means all the source code for all modules it contains, plus any
  794: @c associated interface definition files, plus the scripts used to
  795: @c control compilation and installation of the executable.  However, as a
  796: @c special exception, the source code distributed need not include
  797: @c anything that is normally distributed (in either source or binary
  798: @c form) with the major components (compiler, kernel, and so on) of the
  799: @c operating system on which the executable runs, unless that component
  800: @c itself accompanies the executable.
  801: なお、ソース・コードとは、変更作業に適した記述形式を指します。
  802: また、実行可能形式のファイルに対応するソース・コード一式とは、
  803: それに含まれる全モジュールに対応する全てのソース・コード、
  804: 及びあらゆる関連のインタフェース定義ファイル、
  805: 及び実行を可能にするコンパイルとインストールの制御に関する記述を指します。
  806: 特別な例外として、実行可能なファイルが動作するオペレーティング・システムの
  807: 主要な構成要素(コンパイラ、カーネルなど)と共に
  808: (ソース・コード又はバイナリのどちらかで)頒布されているものについては、
  809: その構成要素自体が実行形式に付随していない場合に限り、
  810: 頒布されるソース・コードに含める必要はありません。
  811: 
  812: @c If distribution of executable or object code is made by offering
  813: @c access to copy from a designated place, then offering equivalent
  814: @c access to copy the source code from the same place counts as
  815: @c distribution of the source code, even though third parties are not
  816: @c compelled to copy the source along with the object code.
  817: 実行可能形式またはオブジェクト・コードの頒布が、
  818: 指示された場所からの複製のためのアクセス権の賦与である場合、
  819: 同じ場所からのソース・コードの複製のための同等なアクセス権を賦与すれば、
  820: たとえ第三者にオブジェクト・コードと共にソースの複製を強いなくとも、
  821: ソース・コードを頒布したものとみなします。
  822: 
  823: @item
  824: @c You may not copy, modify, sublicense, or distribute the Program
  825: @c except as expressly provided under this License.  Any attempt
  826: @c otherwise to copy, modify, sublicense or distribute the Program is
  827: @c void, and will automatically terminate your rights under this License.
  828: @c However, parties who have received copies, or rights, from you under
  829: @c this License will not have their licenses terminated so long as such
  830: @c parties remain in full compliance.
  831: 本使用許諾が明示的に許諾している場合を除き、あなたは、
  832: 「プログラム」を複製、変更、サブライセンス、頒布することができません。
  833: 本使用許諾に従わずに「プログラム」を複製、変更、サブライセンス、
  834: 頒布しようとする行為は、それ自体が無効であり、且つ、
  835: 本使用許諾があなたに許諾している「プログラム」の権利を自動的に消滅させます。
  836: その場合、本使用許諾に従ってあなたから複製物やその権利を得ている第三者は、
  837: 本使用許諾に完全に従っている場合に限り、
  838: 引続き有効な使用権限を持つものとします。
  839: 
  840: @item
  841: @c You are not required to accept this License, since you have not
  842: @c signed it.  However, nothing else grants you permission to modify or
  843: @c distribute the Program or its derivative works.  These actions are
  844: @c prohibited by law if you do not accept this License.  Therefore, by
  845: @c modifying or distributing the Program (or any work based on the
  846: @c Program), you indicate your acceptance of this License to do so, and
  847: @c all its terms and conditions for copying, distributing or modifying
  848: @c the Program or works based on it.
  849: あなたはまだ同意の印として署名していないので、
  850: 本使用許諾を受け入れる必要はありません。
  851: しかし、あなたに「プログラム」又はその派生物を変更又は再頒布する許可を
  852: 与えるものは本使用許諾以外にはありません。
  853: これらの行為は、あなたがもし本使用許諾を受け入れないのであれば、
  854: 法律によって禁じられます。
  855: 従って、あなたが「プログラム」(又は「プログラム生成物」)の変更又は頒布を
  856: 行えば、それ自体であなたは本使用許諾を受け入れ、且つ、
  857: 「プログラム」又はその「プログラム生成物」の複製、頒布、変更に
  858: 関するこれらの条項と条件の全てを受け入れたことを示します。
  859: 
  860: @item
  861: @c Each time you redistribute the Program (or any work based on the
  862: @c Program), the recipient automatically receives a license from the
  863: @c original licensor to copy, distribute or modify the Program subject to
  864: @c these terms and conditions.  You may not impose any further
  865: @c restrictions on the recipients' exercise of the rights granted herein.
  866: @c You are not responsible for enforcing compliance by third parties to
  867: @c this License.
  868: あなたが「プログラム」(又はその「プログラム生成物」)を再頒布すると自動的に、
  869: その受領者は、元の使用許諾者から、本使用許諾の条項に従って「プログラム」を
  870: 複製、頒布、変更することを内容とする使用許諾を受けたものとします。
  871: あなたは、受領者に許諾された権利の行使について、
  872: さらに制約を加えることはできません。
  873: あなたには、第三者に本使用許諾の受け入れを強いる責任はありません。
  874: 
  875: @item
  876: @c If, as a consequence of a court judgment or allegation of patent
  877: @c infringement or for any other reason (not limited to patent issues),
  878: @c conditions are imposed on you (whether by court order, agreement or
  879: @c otherwise) that contradict the conditions of this License, they do not
  880: @c excuse you from the conditions of this License.  If you cannot
  881: @c distribute so as to satisfy simultaneously your obligations under this
  882: @c License and any other pertinent obligations, then as a consequence you
  883: @c may not distribute the Program at all.  For example, if a patent
  884: @c license would not permit royalty-free redistribution of the Program by
  885: @c all those who receive copies directly or indirectly through you, then
  886: @c the only way you could satisfy both it and this License would be to
  887: @c refrain entirely from distribution of the Program.
  888: 裁判所の判決、又は特許侵害の申し立て、又は(特許問題に限らない)
  889: 何らかの理由の結果として、あなたに課せられた条件が本使用許諾と
  890: 相入れないものであったとしても(裁判所の命令、契約、その他によるものであれ)、
  891: 本使用許諾の条件が免除されるものではありません。
  892: 本使用許諾による責務と、その他の何らかの関連責務を同時に満たす態様で
  893: 頒布することができないならば、
  894: あなたは「プログラム」を全く頒布してはいけません。
  895: 例えば、特許権の内容が、あなたから直接又は間接に複製を受け取った全ての人に
  896: 使用料のないプログラムの再頒布を許さないものであれば、
  897: あなたがかかる特許上の要請と本使用許諾の両方を満足させる方法は、
  898: 「プログラム」の頒布を完全に断念することだけです。
  899: 
  900: @c If any portion of this section is held invalid or unenforceable under
  901: @c any particular circumstance, the balance of the section is intended to
  902: @c apply and the section as a whole is intended to apply in other
  903: @c circumstances.
  904: 本条項の或る部分が何らかの特別な状況下で無効または適用不可能になった場合、
  905: 本条項のその他の残りの部分が適用されるように意図されており、また、
  906: 本条項は全体としてその他の状況に当てはまるように意図されています。
  907: 
  908: @c It is not the purpose of this section to induce you to infringe any
  909: @c patents or other property right claims or to contest validity of any
  910: @c such claims; this section has the sole purpose of protecting the
  911: @c integrity of the free software distribution system, which is
  912: @c implemented by public license practices.  Many people have made
  913: @c generous contributions to the wide range of software distributed
  914: @c through that system in reliance on consistent application of that
  915: @c system; it is up to the author/donor to decide if he or she is willing
  916: @c to distribute software through any other system and a licensee cannot
  917: @c impose that choice.
  918: 本条項の目的は、特許やその他の財産権を侵害したり、
  919: そのような権利に基づく主張の妥当性を争うようにあなたに
  920: 勧めることではありません。
  921: 本条項の唯一の目的は、フリー・ソフトウェアの頒布システムの完全性を守ることで、
  922: それは公有使用許諾の実践によって履行されます。
  923: 多くの人々が、このシステムの一貫した適用を信頼して、
  924: このシステムを通じて頒布されている幅広い範囲のソフトウェアに惜しみない貢献を
  925: してくれました。
  926: 作成者や寄贈者が他の何らかのシステムを通じてソフトウェアを
  927: 頒布したいと決めることは彼らの自由意志であり、
  928: 使用許諾を受ける者はその選択を強いることはできません。
  929: 
  930: @c This section is intended to make thoroughly clear what is believed to
  931: @c be a consequence of the rest of this License.
  932: 本条項は、本使用許諾の他の条項の意味内容が何であるかを
  933: 完全に明らかにすることを意図しています。
  934: 
  935: @item
  936: @c If the distribution and/or use of the Program is restricted in
  937: @c certain countries either by patents or by copyrighted interfaces, the
  938: @c original copyright holder who places the Program under this License
  939: @c may add an explicit geographical distribution limitation excluding
  940: @c those countries, so that distribution is permitted only in or among
  941: @c countries not thus excluded.  In such case, this License incorporates
  942: @c the limitation as if written in the body of this License.
  943: 「プログラム」の頒布・使用が、ある国において特許又は著作権で
  944: 保護されたインタフェースのどちらかで制限される場合、
  945: 「プログラム」を本使用許諾下においた原著作権保持者は、
  946: その国を除外する旨の明示的な頒布地域制限を加え、
  947: それ以外の(除外されない)国に限定して頒布が
  948: 許されるようにすることができます。
  949: そのような場合、その制限を本使用許諾の本文に
  950: あたかも書かれているかのように本使用許諾の中に組み入れられるものとします。
  951: 
  952: @item
  953: @c The Free Software Foundation may publish revised and/or new versions
  954: @c of the General Public License from time to time.  Such new versions will
  955: @c be similar in spirit to the present version, but may differ in detail to
  956: @c address new problems or concerns.
  957: Free Software Foundation は随時、本一般公有使用許諾の改訂版、
  958: 又は新版を公表することがあります。
  959: そのような新しいバージョンは、
  960: 現行のバージョンと基本的に変わるところはありませんが、
  961: 新しい問題や懸案事項に対応するために細部では異なるかもしれません。
  962: 
  963: @c Each version is given a distinguishing version number.  If the Program
  964: @c specifies a version number of this License which applies to it and ``any
  965: @c later version'', you have the option of following the terms and conditions
  966: @c either of that version or of any later version published by the Free
  967: @c Software Foundation.  If the Program does not specify a version number of
  968: @c this License, you may choose any version ever published by the Free Software
  969: @c Foundation.
  970: 各バージョンは、バージョン番号によって区別します。
  971: 「プログラム」中に本使用許諾のバージョン番号の指定がある場合は、
  972: その指定されたバージョンか、又はその後にFree Software Foundationから
  973: 公表されているいずれかのバージョンから1つを選択して、
  974: その条項と条件に従ってください。
  975: 「プログラム」中に本使用許諾のバージョン番号の指定がない場合は、
  976: Free Software Foundation が公表したどのバージョンでも選択することができます。
  977: 
  978: @item
  979: @c If you wish to incorporate parts of the Program into other free
  980: @c programs whose distribution conditions are different, write to the author
  981: @c to ask for permission.  For software which is copyrighted by the Free
  982: @c Software Foundation, write to the Free Software Foundation; we sometimes
  983: @c make exceptions for this.  Our decision will be guided by the two goals
  984: @c of preserving the free status of all derivatives of our free software and
  985: @c of promoting the sharing and reuse of software generally.
  986: 「プログラム」の一部を頒布条件の異なる他のフリー・プログラムに
  987: 組み込みたい場合は、その開発者に書面で許可を求めてください。 
  988: Free Software Foundation が著作権を持っているソフトウェアについては、
  989: Free Software Foundation へ書面を提出してください。
  990: このような場合に対応するために我々は例外的処理をすることもありますが、
  991: その判断基準となるのは、次の2つの目標の実現に合致するか否かという点です。
  992: 即ち、1つは我々のフリー・ソフトウェアの全ての派生物を
  993: フリーな状態に保つことであり、もう1つはソフトウェアの共有と再利用とを
  994: 広く促進させることです。
  995: 
  996: @iftex
  997: @c @heading NO WARRANTY
  998: @heading 無保証
  999: @end iftex
 1000: @ifinfo
 1001: @c @center NO WARRANTY
 1002: @center 無保証
 1003: @end ifinfo
 1004: 
 1005: @item
 1006: @c BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 1007: @c FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW@.  EXCEPT WHEN
 1008: @c OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 1009: @c PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
 1010: @c OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 1011: @c MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE@.  THE ENTIRE RISK AS
 1012: @c TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU@.  SHOULD THE
 1013: @c PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
 1014: @c REPAIR OR CORRECTION.
 1015: 「プログラム」は無償で使用許諾されますので、適用法令の範囲内で、
 1016: 「プログラム」の保証は一切ありません。
 1017: 著作権者やその他の第三者は全く無保証で「そのまま」の状態で、且つ、
 1018: 明示か暗黙であるかを問わず一切の保証をつけないで提供するものとします。
 1019: ここでいう保証とは、市場性や特定目的適合性についての暗黙の保証も含まれますが、
 1020: それに限定されるものではありません。
 1021: 「プログラム」の品質や性能に関する全てのリスクはあなたが負うものとします。
 1022: 「プログラム」に欠陥があるとわかった場合、
 1023: それに伴う一切の派生費用や修理・訂正に要する費用は全てあなたの負担とします。
 1024: 
 1025: @item
 1026: @c IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 1027: @c WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 1028: @c REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
 1029: @c INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
 1030: @c OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
 1031: @c TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
 1032: @c YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
 1033: @c PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 1034: @c POSSIBILITY OF SUCH DAMAGES.
 1035: 適用法令の定め、又は書面による合意がある場合を除き、
 1036: 著作権者や上記許諾を受けて「プログラム」の変更・再頒布を為し得る第三者は、
 1037: 「プログラム」を使用したこと、
 1038: または使用できないことに起因する一切の損害について何らの責任も負いません。
 1039: 著作権者や前記の第三者が、そのような損害の発生する可能性について
 1040: 知らされていた場合でも同様です。
 1041: なお、ここでいう損害には通常損害、特別損害、偶発損害、間接損害が含まれます
 1042: (データの消失、又はその正確さの喪失、あなたや第三者が被った損失、
 1043: 他のプログラムとのインタフェースの不適合化、等も含まれますが、
 1044: これに限定されるものではありません)。
 1045: @end enumerate
 1046: 
 1047: @iftex
 1048: @c @heading END OF TERMS AND CONDITIONS
 1049: @heading 以上
 1050: @end iftex
 1051: @ifinfo
 1052: @c @center END OF TERMS AND CONDITIONS
 1053: @center 以上
 1054: @end ifinfo
 1055: 
 1056: @c = 以下は日本語訳に関した部分
 1057: @heading 注意
 1058:  英文文書(GNU General Public License)を正式文書とする。
 1059: この和文文書は弁護士の意見を採り入れて、
 1060: できるだけ正確に英文文書を翻訳したものであるが、
 1061: 法律的に有効な契約書ではない。
 1062: 
 1063: @unnumberedsec 和文文書自体の再配布に関して
 1064:  いかなる媒体でも次の条件がすべて満たされている場合に限り、
 1065: 本和文文書をそのまま複写し配布することを許可する。
 1066: また、あなたは第三者に対して本許可告知と同一の許可を与える場合に限り、
 1067: 再配布することが許可されています。
 1068: @itemize @bullet
 1069: @item
 1070: 受領、配布されたコピーに著作権表示および本許諾告知が
 1071: 前もって載せられていること。 
 1072: @item
 1073: コピーの受領者がさらに再配布する場合、
 1074: その配布者が本告知と同じ許可を与えていること。
 1075: @item
 1076: 和文文書の本文を改変しないこと。
 1077: @end itemize
 1078: 
 1079: @page
 1080: @c @unnumberedsec How to Apply These Terms to Your New Programs
 1081: @unnumberedsec あなたの新しいプログラムにこれらの条項を適用する方法
 1082: 
 1083: @c   If you develop a new program, and you want it to be of the greatest
 1084: @c possible use to the public, the best way to achieve this is to make it
 1085: @c free software which everyone can redistribute and change under these terms.
 1086:  あなたが新しくプログラムを作成し、それを公用に供したい場合は、
 1087: プログラムをフリー・ソフトウェアにして、
 1088: 全ての人々が以上の各条項に従ってこれを再頒布や変更をすることが
 1089: できるようにするのが最良の方法です。
 1090: 
 1091: @c   To do so, attach the following notices to the program.  It is safest
 1092: @c to attach them to the start of each source file to most effectively
 1093: @c convey the exclusion of warranty; and each file should have at least
 1094: @c the ``copyright'' line and a pointer to where the full notice is found.
 1095:  そうするためには、プログラムに以下の表示をしてください。
 1096: その場合、無保証であるということを最も効果的に伝えるために、
 1097: ソース・ファイルの冒頭にその全文を表示すれば最も安全ですが、
 1098: その他の方法で表示する場合でも、「著作権表示」と全文を読み出す為の
 1099: アドレスへのポインタだけはファイル上に表示しておいてください。
 1100: 
 1101: @smallexample
 1102: @c @var{one line to give the program's name and an idea of what it does.}
 1103: @c Copyright (C) 19@var{yy}  @var{name of author}
 1104: @var{プログラム名とどんな動作をするものかについての簡単な説明の行}
 1105: Copyright(C) 19○○年、@var{著作権者名}
 1106: 
 1107: @c This program is free software; you can redistribute it and/or
 1108: @c modify it under the terms of the GNU General Public License
 1109: @c as published by the Free Software Foundation; either version 2
 1110: @c of the License, or (at your option) any later version.
 1111: 本プログラムはフリー・ソフトウェアです。
 1112: あなたは、Free Software Foundationが公表したGNU 一般公有使用許諾の
 1113: 「バージョン2」或いはそれ以降の各バージョンの中からいずれかを選択し、
 1114: そのバージョンが定める条項に従って本プログラムを
 1115: 再頒布または変更することができます。
 1116: 
 1117: @c This program is distributed in the hope that it will be useful,
 1118: @c but WITHOUT ANY WARRANTY; without even the implied warranty of
 1119: @c MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE@.  See the
 1120: @c GNU General Public License for more details.
 1121: 本プログラムは有用とは思いますが、頒布にあたっては、
 1122: 市場性及び特定目的適合性についての暗黙の保証を含めて、
 1123: いかなる保証も行ないません。
 1124: 詳細についてはGNU 一般公有使用許諾書をお読みください。
 1125: 
 1126: @c You should have received a copy of the GNU General Public License along
 1127: @c with this program; if not, write to the Free Software Foundation, Inc.,
 1128: @c 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 1129: あなたは、本プログラムと一緒にGNU一般公有使用許諾の写しを
 1130: 受け取っているはずです。
 1131: そうでない場合は、@*
 1132:  Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA
 1133: @footnote{【注意】現在、このバージョン2の発行者(FSF)住所は、
 1134: 正式に新しい住所の
 1135: 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA に変わっている。}
 1136: @ifinfo
 1137: 【注意】 現在、このバージョン2の発行者(FSF)住所は、正式に新しい住所の
 1138:  59 Temple Place - Suite 330, Boston, MA 02111-1307, USA に変わっている。
 1139: @end ifinfo
 1140: へ手紙を書いてください。
 1141: @end smallexample
 1142: 
 1143: @c Also add information on how to contact you by electronic and paper mail.
 1144: また、ユーザが電子メイルや書信であなたと連絡をとる方法についての情報も
 1145: 書き添えてください。
 1146: 
 1147: @c If the program is interactive, make it output a short notice like this
 1148: @c when it starts in an interactive mode:
 1149: プログラムが対話的に動作する場合は、
 1150: 対話モードで起動した時に次のような短い告知文が表示されるようにしてください。
 1151: 
 1152: @smallexample
 1153: @c Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
 1154: @c Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
 1155: @c type `show w'.  This is free software, and you are welcome
 1156: @c to redistribute it under certain conditions; type `show c' 
 1157: @c for details.
 1158: Gnomovision バージョン69、Copyright(C)19○○年 @var{著作権者名}
 1159: Gnomovision は完全に無保証です。詳細は show w とタイプしてください。
 1160: これはフリー・ソフトウェアなので、特定の条件の下でこれを再頒布する
 1161: ことができます。詳細は show c とタイプしてください。
 1162: @end smallexample
 1163: 
 1164: @c The hypothetical commands @samp{show w} and @samp{show c} should show
 1165: @c the appropriate parts of the General Public License.  Of course, the
 1166: @c commands you use may be called something other than @samp{show w} and
 1167: @c @samp{show c}; they could even be mouse-clicks or menu items---whatever
 1168: @c suits your program.
 1169: 上記の@samp{show w}や@samp{show c}は各々、
 1170: 本一般公有使用許諾の関連する部分を表示するコマンドを指します。
 1171: もちろん、あなたが使うこれらのコマンドは@samp{show w}や@samp{show c}といった
 1172: 呼び名でなくても構いません。
 1173: さらに、それらのコマンドはあなたのプログラムに合わせる為に、
 1174: マウスでクリックしたりメニュー形式にすることもできます。
 1175: 
 1176: @c You should also get your employer (if you work as a programmer) or your
 1177: @c school, if any, to sign a ``copyright disclaimer'' for the program, if
 1178: @c necessary.  Here is a sample; alter the names:
 1179: また、必要と認めた場合には、あなたの雇い主
 1180: (あなたがプログラマとして働いている場合)や在籍する学校から、
 1181: そのプログラムに対する「著作権放棄」を認めた署名入りの書面を入手してください。
 1182: ここにその文例を載せます。名前は変えてください。
 1183: 
 1184: @smallexample
 1185: @group
 1186: @c Yoyodyne, Inc., hereby disclaims all copyright
 1187: @c interest in the program `Gnomovision'
 1188: @c (which makes passes at compilers) written 
 1189: @c by James Hacker.
 1190: Yoyodyne, Inc. は、James Hacker が開発したプログラム`Gnomovision' 
 1191: (コンパイラにつなげるプログラム)についての著作権法上の全ての権利を放棄する。
 1192: 
 1193: @c @var{signature of Ty Coon}, 1 April 1989
 1194: @c Ty Coon, President of Vice
 1195: @var{Ty Coon の署名}, 1 April 1989
 1196: Ty Coon, 副社長
 1197: @end group
 1198: @end smallexample
 1199: 
 1200: @c This General Public License does not permit incorporating your program into
 1201: @c proprietary programs.  If your program is a subroutine library, you may
 1202: @c consider it more useful to permit linking proprietary applications with the
 1203: @c library.  If this is what you want to do, use the GNU Library General
 1204: @c Public License instead of this License.
 1205: 本一般公有使用許諾は、あなたのプログラムを財産権の対象となっている
 1206: 他のプログラムに組み込むことは認めていません。
 1207: あなたのプログラムがサブルーチン・ライブラリであって、
 1208: あなたがそのライブラリを財産権の対象となっている他のアプリケーションと
 1209: リンクさせることによって、さらに有用なものにしようとする場合には、
 1210: 本使用許諾書の代わりに、GNUライブラリ一般公有使用許諾書に従ってください。
 1211: @c =============================================================
 1212: @c = 以上のGPLの日本語訳に関しての問い合わせは、以下のアドレスに
 1213: @c = お願いいたします。
 1214: @c = mieko@gnu.org もしくは hikichi@gnu.org
 1215: @c =============================================================
 1216: 
 1217: 
 1218: 
 1219: @node Concepts, Examples, Copying, Top
 1220: @c @chapter The Concepts of Bison
 1221: @chapter Bisonの概念
 1222: 
 1223: @c This chapter introduces many of the basic concepts without which the
 1224: @c details of Bison will not make sense.  If you do not already know how to
 1225: @c use Bison or Yacc, we suggest you start by reading this chapter carefully.
 1226: 
 1227: この章では、Bisonの詳細を理解するのに欠くことのできない、
 1228: 多くの基礎概念を説明します。
 1229: まだBisonやyaccの使い方を知らない方は、
 1230: この章を注意深く読むことから始めてください。
 1231: 
 1232: @menu
 1233: * Language and Grammar::  Languages and context-free grammars,
 1234:                             as mathematical ideas.
 1235: * Grammar in Bison::  How we represent grammars for Bison's sake.
 1236: * Semantic Values::   Each token or syntactic grouping can have
 1237:                         a semantic value (the value of an integer,
 1238:                         the name of an identifier, etc.).
 1239: * Semantic Actions::  Each rule can have an action containing C code.
 1240: * Bison Parser::      What are Bison's input and output,
 1241:                         how is the output used?
 1242: * Stages::            Stages in writing and running Bison grammars.
 1243: * Grammar Layout::    Overall structure of a Bison grammar file.
 1244: @end menu
 1245: 
 1246: 
 1247: @c =====================================================================
 1248: @node Language and Grammar, Grammar in Bison,  , Concepts
 1249: @c @section Languages and Context-Free Grammars
 1250: @section 言語と文脈自由文法
 1251: 
 1252: @cindex context-free grammar
 1253: @cindex grammar, context-free
 1254: @cindex 文脈自由文法
 1255: @cindex 文法
 1256: @c In order for Bison to parse a language, it must be described by a
 1257: @c @dfn{context-free grammar}.  This means that you specify one or more
 1258: @c @dfn{syntactic groupings} and give rules for constructing them from their
 1259: @c parts.  For example, in the C language, one kind of grouping is called an
 1260: @c `expression'.  One rule for making an expression might be, ``An expression
 1261: @c can be made of a minus sign and another expression''.  Another would be,
 1262: @c ``An expression can be an integer''.  As you can see, rules are often
 1263: @c recursive, but there must be at least one rule which leads out of the
 1264: @c recursion.
 1265: 
 1266: Bisonが言語を解析するためには、その言語が
 1267: @dfn{文脈自由文法(context-free grammar)}で記述されている必要があります。
 1268: すなわち、1個以上の@dfn{文法グループ(syntactic groupings)}を定め、
 1269: その文法グループを部品から組み立てる規則を与える必要があります。
 1270: たとえば、C言語では、ある種のグループは「式」と呼ばれます。
 1271: 式を作る規則の1つは、
 1272: 「1つの式とは、別の式にマイナス記号を付けたものでもよい」かもしれません。
 1273: 別の規則は、「1つの式とは、整数でもよい」かもしれません。
 1274: ここから解るように、規則はしばしば再帰的になりますが、
 1275: 再帰を始めるための少なくとも1個の規則が必要です。
 1276: 
 1277: @cindex BNF
 1278: @cindex Backus-Naur form
 1279: @cindex バッカス-ナウア記法
 1280: @c The most common formal system for presenting such rules for humans to read
 1281: @c is @dfn{Backus-Naur Form} or ``BNF'', which was developed in order to
 1282: @c specify the language Algol 60.  Any grammar expressed in BNF is a
 1283: @c context-free grammar.  The input to Bison is essentially machine-readable
 1284: @c BNF.
 1285: 
 1286: このような規則を人間が読めるように表現する、もっとも一般的な形式的な方法は、
 1287: @dfn{バッカス-ナウア記法(Backus-Naur form)}略して``BNF''です。
 1288: これは、Algol 60言語を定義するために開発されました。
 1289: BNFで表現された任意の言語は、文脈自由言語です。
 1290: Bisonへの入力は、本質的には、機械可読なBNFです。
 1291: 
 1292: @c Not all context-free languages can be handled by Bison, only those
 1293: @c that are LALR(1).  In brief, this means that it must be possible to
 1294: @c tell how to parse any portion of an input string with just a single
 1295: @c token of look-ahead.  Strictly speaking, that is a description of an
 1296: @c LR(1) grammar, and LALR(1) involves additional restrictions that are
 1297: @c hard to explain simply; but it is rare in actual practice to find an
 1298: @c LR(1) grammar that fails to be LALR(1).  @xref{Mystery Conflicts, ,
 1299: @c Mysterious Reduce/Reduce Conflicts}, for more information on this.
 1300: 
 1301: すべての文脈自由言語をBisonで扱えるわけではありません。
 1302: LALR(1)だけを扱えます。
 1303: 簡単に説明すると、ちょうど1個のトークンを先読みすることによって、
 1304: 入力文字列の任意の部分を解析できる必要があるということです。
 1305: 厳密に説明すると、これはLR(1)文法の説明で、
 1306: LALR(1)には簡単に説明できない追加の制限があります。
 1307: しかし、LALR(1)になれないLR(1)文法は、現実にはまれです。
 1308: より詳しい説明は
 1309: @xref{Mystery Conflicts, , Mysterious Reduce/Reduce Conflicts}。
 1310: 
 1311: @cindex symbols (abstract)
 1312: @cindex token
 1313: @cindex syntactic grouping
 1314: @cindex grouping, syntactic
 1315: @cindex シンボル
 1316: @cindex 記号
 1317: @cindex 終端記号
 1318: @cindex 非終端記号
 1319: @cindex トークン
 1320: @cindex 文法グループ
 1321: @cindex グループ
 1322: @c In the formal grammatical rules for a language, each kind of syntactic unit
 1323: @c or grouping is named by a @dfn{symbol}.  Those which are built by grouping
 1324: @c smaller constructs according to grammatical rules are called
 1325: @c @dfn{nonterminal symbols}; those which can't be subdivided are called
 1326: @c @dfn{terminal symbols} or @dfn{token types}.  We call a piece of input
 1327: @c corresponding to a single terminal symbol a @dfn{token}, and a piece
 1328: @c corresponding to a single nonterminal symbol a @dfn{grouping}.@refill
 1329: 
 1330: ある言語についての形式文法的な規則では、
 1331: 文法的な単位またはグループを@dfn{記号(symbol)}と呼びます。
 1332: 文法規則に従って小さい部分から組み立てられた記号を
 1333: @dfn{非終端記号(nonterminal symbol)}といい、
 1334: @dfn{終端記号(terminal symbol)}または@dfn{トークン型(token type)}と呼ばれる
 1335: ものに分解できます。
 1336: 本書では、1個の終端記号に対応する入力の一部分を@dfn{トークン(token)}、
 1337: 1個の非終端記号に対応する入力の一部分を@dfn{グループ(grouping)}と呼びます。
 1338: 
 1339: @c We can use the C language as an example of what symbols, terminal and
 1340: @c nonterminal, mean.  The tokens of C are identifiers, constants (numeric and
 1341: @c string), and the various keywords, arithmetic operators and punctuation
 1342: @c marks.  So the terminal symbols of a grammar for C include `identifier',
 1343: @c `number', `string', plus one symbol for each keyword, operator or
 1344: @c punctuation mark: `if', `return', `const', `static', `int', `char',
 1345: @c `plus-sign', `open-brace', `close-brace', `comma' and many more.  (These
 1346: @c tokens can be subdivided into characters, but that is a matter of
 1347: @c lexicography, not grammar.)
 1348: 
 1349: 何が終端記号で何が非終端記号かを示すために、
 1350: 例としてC言語を使います。
 1351: Cのトークンは、識別子、定数(数値または文字列)、さまざまな予約語、
 1352: 算術演算子、区切り記号です。
 1353: C言語の終端記号には、「識別子」、「数値」、「文字列」、そして、
 1354: 予約語、演算子、区切り記号のそれぞれに対する記号、
 1355: すなわち、「if」、「return」、「const」、「static」、「int」、「char」、
 1356: 「プラス記号」、「開きブレース」、「閉じブレース」、「カンマ」、
 1357: などが含まれます
 1358: (これらのトークンは文字に分解できますが、
 1359: それは文法の問題ではなく、字句解析の問題です)。
 1360: 
 1361: @c Here is a simple C function subdivided into tokens:
 1362: 
 1363: 次の例は、トークンに分解されたCの関数です。
 1364: 
 1365: @example
 1366: @c int             /* @r{keyword `int'} */
 1367: @c square (x)      /* @r{identifier, open-paren,} */
 1368: @c                 /* @r{identifier, close-paren} */
 1369: @c      int x;     /* @r{keyword `int', identifier, semicolon} */
 1370: @c @{               /* @r{open-brace} */
 1371: @c   return x * x; /* @r{keyword `return', identifier,} */
 1372: @c                 /* @r{asterisk, identifier, semicolon} */
 1373: @c @}               /* @r{close-brace} */
 1374: int             /* @r{予約語 `int'} */
 1375: square (x)      /* @r{識別子, 開きかっこ,} */
 1376:                 /* @r{識別子, 閉じかっこ} */
 1377:      int x;     /* @r{予約語 `int', 識別子, セミコロン} */
 1378: @{               /* @r{開きブレース} */
 1379:   return x * x; /* @r{予約語 `return', 識別子,} */
 1380:                 /* @r{アスタリスク, 識別子, セミコロン} */
 1381: @}               /* @r{閉じブレース} */
 1382: @end example
 1383: 
 1384: @c The syntactic groupings of C include the expression, the statement, the
 1385: @c declaration, and the function definition.  These are represented in the
 1386: @c grammar of C by nonterminal symbols `expression', `statement',
 1387: @c `declaration' and `function definition'.  The full grammar uses dozens of
 1388: @c additional language constructs, each with its own nonterminal symbol, in
 1389: @c order to express the meanings of these four.  The example above is a
 1390: @c function definition; it contains one declaration, and one statement.  In
 1391: @c the statement, each @samp{x} is an expression and so is @samp{x * x}.
 1392: 
 1393: Cの文法的なグループには、式、文、宣言、関数定義が含まれます。
 1394: これらは、Cの文法で、非終端記号、「式」、「文」、「宣言」、
 1395: 「関数定義」として表されます。
 1396: 完全な文法では、上記の4つの意味を表現するために、
 1397: それぞれの非終端記号について、数十個の追加の言語構築が必要です。
 1398: 上記の例で、関数定義は、宣言と文を含みます。
 1399: 文の中で、それぞれの@samp{x}は式であり、
 1400: @samp{x * x}も式です。
 1401: 
 1402: @c Each nonterminal symbol must have grammatical rules showing how it is made
 1403: @c out of simpler constructs.  For example, one kind of C statement is the
 1404: @c @code{return} statement; this would be described with a grammar rule which
 1405: @c reads informally as follows:
 1406: 
 1407: それぞれの非終端記号には、それがより単純な構成要素からどのように作られるか
 1408: 示すために、文法規則が必要です。
 1409: たとえば、Cの文の1つである@code{return}文について、
 1410: 文法規則を形式ばらずに書くと、次のようになります。
 1411: 
 1412: @quotation
 1413: @c A `statement' can be made of a `return' keyword, an `expression' and a
 1414: @c `semicolon'.
 1415: 「文」は、キーワード「@code{return}」、「式」、「セミコロン」から
 1416: 作ることができる。
 1417: @end quotation
 1418: 
 1419: @noindent
 1420: @c There would be many other rules for `statement', one for each kind of
 1421: @c statement in C.
 1422: Cの各種の文について、「文」には多くの他の規則があるでしょう。
 1423: 
 1424: @cindex start symbol
 1425: @cindex 開始記号
 1426: @c One nonterminal symbol must be distinguished as the special one which
 1427: @c defines a complete utterance in the language.  It is called the @dfn{start
 1428: @c symbol}.  In a compiler, this means a complete input program.  In the C
 1429: @c language, the nonterminal symbol `sequence of definitions and declarations'
 1430: @c plays this role.
 1431: @c
 1432: 1つの非終端記号が、言語の全体を表現するように、
 1433: 特別なものとして識別される必要があります。
 1434: これを@dfn{開始記号(start symbol)}と呼びます。
 1435: コンパイラでは、これは完全な入力プログラムを意味します。
 1436: C言語では、非終端記号「定義と宣言の並び」が、この働きをします。
 1437: 
 1438: @c For example, @samp{1 + 2} is a valid C expression---a valid part of a C
 1439: @c program---but it is not valid as an @emph{entire} C program.  In the
 1440: @c context-free grammar of C, this follows from the fact that `expression' is
 1441: @c not the start symbol.
 1442: 
 1443: たとえば、@samp{1 + 2}は有効なCの式で、
 1444: Cのプログラムの有効な一部分ですが、
 1445: Cプログラム@emph{全体}としては無効です。
 1446: したがって、Cの文脈自由文法では、「式」は開始記号でないとわかります。
 1447: 
 1448: @c The Bison parser reads a sequence of tokens as its input, and groups the
 1449: @c tokens using the grammar rules.  If the input is valid, the end result is
 1450: @c that the entire token sequence reduces to a single grouping whose symbol is
 1451: @c the grammar's start symbol.  If we use a grammar for C, the entire input
 1452: @c must be a `sequence of definitions and declarations'.  If not, the parser
 1453: @c reports a syntax error.
 1454: 
 1455: Bison構文解析器は、入力としてトークンの列を読み、
 1456: 文法規則を使ってトークンをグループにします。
 1457: もし入力が有効であれば、最終的な結果として、トークンの列全体が
 1458: 文法の開始記号である1つのグループの記号に還元されます。
 1459: もしわれわれがCの文法を使うならば、入力全体は
 1460: 「定義と宣言の列」の必要があります。
 1461: もしそうでなければ、構文解析器が文法エラーを報告します。
 1462: 
 1463: 
 1464: @c =====================================================================
 1465: @node Grammar in Bison, Semantic Values, Language and Grammar, Concepts
 1466: @c @section From Formal Rules to Bison Input
 1467: @section 形式規則からBisonの入力へ
 1468: @cindex Bison grammar
 1469: @cindex Bison 文法
 1470: @cindex grammar, Bison
 1471: @cindex formal grammar
 1472: @cindex 形式文法
 1473: 
 1474: @c A formal grammar is a mathematical construct.  To define the language
 1475: @c for Bison, you must write a file expressing the grammar in Bison syntax:
 1476: @c a @dfn{Bison grammar} file.  @xref{Grammar File, ,Bison Grammar Files}.
 1477: 
 1478: 形式文法(formal grammer)は、数学的な構成です。
 1479: Bisonのために言語を定義するためには、Bisonの書式で文法を記述した
 1480: @dfn{Bison文法(Bison grammer)}ファイルを書く必要があります。
 1481: @xref{Grammar File, ,Bison Grammar Files}。
 1482: 
 1483: @c A nonterminal symbol in the formal grammar is represented in Bison input
 1484: @c as an identifier, like an identifier in C.  By convention, it should be
 1485: @c in lower case, such as @code{expr}, @code{stmt} or @code{declaration}.
 1486: 
 1487: 形式文法の中での1つの非終端記号は、Bisonの入力の中で、
 1488: Cの識別子のような、1つの識別子として表現されます。
 1489: @code{expr}、@code{stmt}、@code{declaration}のように、
 1490: 通常、非終端記号は小文字で書きます。
 1491: 
 1492: @c The Bison representation for a terminal symbol is also called a @dfn{token
 1493: @c type}.  Token types as well can be represented as C-like identifiers.  By
 1494: @c convention, these identifiers should be upper case to distinguish them from
 1495: @c nonterminals: for example, @code{INTEGER}, @code{IDENTIFIER}, @code{IF} or
 1496: @c @code{RETURN}.  A terminal symbol that stands for a particular keyword in
 1497: @c the language should be named after that keyword converted to upper case.
 1498: @c The terminal symbol @code{error} is reserved for error recovery.
 1499: @c @xref{Symbols}.
 1500: 
 1501: 終端記号に対するBisonの表現は、
 1502: @dfn{トークン型(token type)}ともいいます。
 1503: トークン型は、C言語で使われるような識別子であるかもしれません。
 1504: 通常、非終端記号からこれらを区別するために、大文字で書きます。
 1505: たとえば、@code{INTEGER}、@code{IDENTIFIER}、@code{IF}、@code{RETURN}
 1506: のように書きます。
 1507: 言語の個々のキーワードを表す終端記号は、
 1508: キーワードを大文字に変換してから命名するべきです。
 1509: @cindex error
 1510: 終端記号@code{error}は、エラーからの回復処理のために予約されています。
 1511: @xref{Symbols}。
 1512: 
 1513: @c A terminal symbol can also be represented as a character literal, just like
 1514: @c a C character constant.  You should do this whenever a token is just a
 1515: @c single character (parenthesis, plus-sign, etc.): use that same character in
 1516: @c a literal as the terminal symbol for that token.
 1517: 
 1518: ある終端記号は、C言語の文字定数のような、1文字リテラルを表している
 1519: かもしれません。
 1520: トークンがちょうど1文字である(たとえば、かっこ、プラス記号など)ならば必ず、
 1521: そのトークンに対する終端記号として、同じ文字を使うべきです。
 1522: 
 1523: @c A third way to represent a terminal symbol is with a C string constant
 1524: @c containing several characters.  @xref{Symbols}, for more information.
 1525: 
 1526: 終端記号を表す第3の方法は、何文字かを含むC言語の文字列定数です。
 1527: 詳細は@xref{Symbols}。
 1528: 
 1529: @c The grammar rules also have an expression in Bison syntax.  For example,
 1530: @c here is the Bison rule for a C @code{return} statement.  The semicolon in
 1531: @c quotes is a literal character token, representing part of the C syntax for
 1532: @c the statement; the naked semicolon, and the colon, are Bison punctuation
 1533: @c used in every rule.
 1534: 
 1535: 文法規則は、Bisonの文法の中で、もう1つの式を持ちます。
 1536: たとえば、C言語の@code{return}文に対するBisonの規則があります。
 1537: クォート(')で囲まれたセミコロンは、文に対するC言語の文法の一部分を表す、
 1538: 1文字のリテラルトークンです。
 1539: クォートで囲まれていないセミコロンとコロンは、
 1540: あらゆる規則の中で使われる、Bisonの区切り文字です。
 1541: 
 1542: @example
 1543: stmt:   RETURN expr ';'
 1544:         ;
 1545: @end example
 1546: 
 1547: @noindent
 1548: @c @xref{Rules, ,Syntax of Grammar Rules}.
 1549: @xref{Rules, ,Syntax of Grammar Rules}。
 1550: 
 1551: 
 1552: @c =====================================================================
 1553: @node Semantic Values, Semantic Actions, Grammar in Bison, Concepts
 1554: @c @section Semantic Values
 1555: @section 意味値
 1556: @cindex semantic value
 1557: @cindex value, semantic
 1558: @cindex 意味値
 1559: @cindex 値
 1560: 
 1561: @c A formal grammar selects tokens only by their classifications: for example,
 1562: @c if a rule mentions the terminal symbol `integer constant', it means that
 1563: @c @emph{any} integer constant is grammatically valid in that position.  The
 1564: @c precise value of the constant is irrelevant to how to parse the input: if
 1565: @c @samp{x+4} is grammatical then @samp{x+1} or @samp{x+3989} is equally
 1566: @c grammatical.@refill
 1567: 
 1568: 形式文法は、トークンを分類法に基づいてのみ、選びます。
 1569: たとえば、ある規則が`integer constant'という終端記号について言及するならば、
 1570: それは、文法的にそこに現れてよい@emph{任意の}整数型定数を意味します。
 1571: その定数の正確な値は、入力が解析される方法と無関係です。
 1572: もし、@samp{x+4}が文法的に正しいならば、@samp{x+1}も、@samp{x+3989}も、
 1573: 同様に文法的に正しいのです。
 1574: 
 1575: @c But the precise value is very important for what the input means once it is
 1576: @c parsed.  A compiler is useless if it fails to distinguish between 4, 1 and
 1577: @c 3989 as constants in the program!  Therefore, each token in a Bison grammar
 1578: @c has both a token type and a @dfn{semantic value}.  @xref{Semantics, ,Defining@c  Language Semantics},
 1579: @c for details.
 1580: 
 1581: しかし、いったん解析されれば、入力にとって正確な値はきわめて重要です。
 1582: プログラム中の定数として4と1と3989を区別できないコンパイラは、
 1583: 役に立ちません。
 1584: そこで、Bison文法の中のそれぞれのトークンは、トークン型のほかに、
 1585: @dfn{意味値(semantic value)}を持ちます。詳細については、
 1586: @xref{Semantics, ,Defining Language Semantics}。
 1587: 
 1588: @c The token type is a terminal symbol defined in the grammar, such as
 1589: @c @code{INTEGER}, @code{IDENTIFIER} or @code{','}.  It tells everything
 1590: @c you need to know to decide where the token may validly appear and how to
 1591: @c group it with other tokens.  The grammar rules know nothing about tokens
 1592: @c except their types.@refill
 1593: 
 1594: トークン型は、@code{INTEGER}、@code{IDENTIFIER}、@code{','}のように、
 1595: 文法の中で定義される終端記号です。
 1596: これは、そのトークンが正しい位置に現れているか確かめ、
 1597: 他のトークンとどのようにグループ化するか決めるために必要な、
 1598: すべての情報を含んでいます。
 1599: 文法規則は、トークンの型以外の何も知りません。
 1600: 
 1601: @c The semantic value has all the rest of the information about the
 1602: @c meaning of the token, such as the value of an integer, or the name of an
 1603: @c identifier.  (A token such as @code{','} which is just punctuation doesn't
 1604: @c need to have any semantic value.)
 1605: 
 1606: 意味値は、トークンに関する、たとえば、整数の値や識別子の名前のような、
 1607: トークン型以外のあらゆる情報を持っています
 1608: (@code{','}のような区切り記号であるトークンは、
 1609: 意味値を持つ必要がありません)。
 1610: 
 1611: @c For example, an input token might be classified as token type
 1612: @c @code{INTEGER} and have the semantic value 4.  Another input token might
 1613: @c have the same token type @code{INTEGER} but value 3989.  When a grammar
 1614: @c rule says that @code{INTEGER} is allowed, either of these tokens is
 1615: @c acceptable because each is an @code{INTEGER}.  When the parser accepts the
 1616: @c token, it keeps track of the token's semantic value.
 1617: 
 1618: たとえば、ある入力されたトークンは、トークン型が@code{INTEGER}で、
 1619: 意味値が4であると分類されるかもしれません。
 1620: 別の入力されたトークンは、同じ@code{INTEGER}型で、
 1621: 値が3989であるかもしれません。
 1622: 文法規則が@code{INTEGER}の出現を許すのならば、
 1623: どちらのトークンも@code{INTEGER}型なので、受け入れられます。
 1624: 構文解析器は、トークンを受け入れるときに、その意味値を記憶します。
 1625: 
 1626: @c Each grouping can also have a semantic value as well as its nonterminal
 1627: @c symbol.  For example, in a calculator, an expression typically has a
 1628: @c semantic value that is a number.  In a compiler for a programming
 1629: @c language, an expression typically has a semantic value that is a tree
 1630: @c structure describing the meaning of the expression.
 1631: 
 1632: それぞれのグループ化は、それに対応する非終端記号とともに、意味値を持てます。
 1633: たとえば、電卓の中では、1つの式は、通常、数値である意味値を持ちます。
 1634: プログラミング言語のコンパイラの中では、1つの式は、通常、
 1635: 式の意味を表す木構造の意味値を持ちます。
 1636: 
 1637: 
 1638: @c =====================================================================
 1639: @node Semantic Actions, Bison Parser, Semantic Values, Concepts
 1640: @c @section Semantic Actions
 1641: @section 意味アクション
 1642: @cindex semantic actions
 1643: @cindex actions, semantic
 1644: @cindex 意味アクション
 1645: @cindex アクション
 1646: 
 1647: @c In order to be useful, a program must do more than parse input; it must
 1648: @c also produce some output based on the input.  In a Bison grammar, a grammar
 1649: @c rule can have an @dfn{action} made up of C statements.  Each time the
 1650: @c parser recognizes a match for that rule, the action is executed.
 1651: @c @xref{Actions}.
 1652: 
 1653: 役に立つようにするためには、プログラムは、入力を解析するだけでなく、
 1654: 入力に基づくなんらかの出力を生成する必要があります。
 1655: Bison文法の中では、文法規則は、
 1656: Cで書かれた@dfn{アクション(action)}を持てます。
 1657: そのルールへのマッチを構文解析器が認識するたびに、アクションが実行されます。
 1658: @xref{Actions}
 1659: 
 1660: @c Most of the time, the purpose of an action is to compute the semantic value
 1661: @c of the whole construct from the semantic values of its parts.  For example,
 1662: @c suppose we have a rule which says an expression can be the sum of two
 1663: @c expressions.  When the parser recognizes such a sum, each of the
 1664: @c subexpressions has a semantic value which describes how it was built up.
 1665: @c The action for this rule should create a similar sort of value for the
 1666: @c newly recognized larger expression.
 1667: 
 1668: 多くの場合に、アクションの目的は、部品の意味値から全体の意味値を
 1669: 計算することです。
 1670: たとえば、1つの式とは2つの式の和でありうると仮定します。
 1671: 構文解析器が和を認識すると、
 1672: 部分式それぞれは、それがどのように構成されたかを表す意味値を持っています。
 1673: アクションは、新しく認識された合成式について、
 1674: 同様の意味値を構成するべきです。
 1675: 
 1676: @c For example, here is a rule that says an expression can be the sum of
 1677: @c two subexpressions:
 1678: 
 1679: 以下に、1つの式が2つの部分式の和となる規則の例を示します。
 1680: 
 1681: @example
 1682: expr: expr '+' expr   @{ $$ = $1 + $3; @}
 1683:         ;
 1684: @end example
 1685: 
 1686: @c @noindent
 1687: @c The action says how to produce the semantic value of the sum expression
 1688: @c from the values of the two subexpressions.
 1689: 
 1690: このアクションは、2個の部分式の値から、
 1691: 式の和の意味値を生成する方法を示しています。
 1692: 
 1693: 
 1694: @c =====================================================================
 1695: @node Bison Parser, Stages, Semantic Actions, Concepts
 1696: @c @section Bison Output: the Parser File
 1697: @section Bisonの出力――構文解析器ファイル
 1698: @cindex Bison parser
 1699: @cindex Bison utility
 1700: @cindex lexical analyzer, purpose
 1701: @cindex parser
 1702: @cindex Bison構文解析器
 1703: @cindex Bisonユーティリティ
 1704: @cindex 字句解析器
 1705: @cindex 構文解析器
 1706: 
 1707: @c When you run Bison, you give it a Bison grammar file as input.  The output
 1708: @c is a C source file that parses the language described by the grammar.
 1709: @c This file is called a @dfn{Bison parser}.  Keep in mind that the Bison
 1710: @c utility and the Bison parser are two distinct programs: the Bison utility
 1711: @c is a program whose output is the Bison parser that becomes part of your
 1712: @c program.
 1713: 
 1714: Bisonを使うときには、入力としてBison文法ファイルを指定します。
 1715: 文法で記述された言語を解析する、Cのソースファイルが出力になります。
 1716: このファイルを@dfn{Bison構文解析器(Bison parser)}と呼びます。
 1717: BisonユーティリティとBison構文解析器は、
 1718: 別のプログラムであることに注意してください。
 1719: Bisonユーティリティの出力がBison構文解析器で、
 1720: あなたのプログラムの一部分になるのです。
 1721: 
 1722: @c The job of the Bison parser is to group tokens into groupings according to
 1723: @c the grammar rules---for example, to build identifiers and operators into
 1724: @c expressions.  As it does this, it runs the actions for the grammar rules it
 1725: @c uses.
 1726: 
 1727: Bison構文解析器の仕事は、文法規則に従って、トークンをグループ化することです。
 1728: たとえば、識別子と演算子から式を組み立てます。
 1729: このために、文法規則に対応するアクションを実行します。
 1730: 
 1731: @c The tokens come from a function called the @dfn{lexical analyzer} that you
 1732: @c must supply in some fashion (such as by writing it in C).  The Bison parser
 1733: @c calls the lexical analyzer each time it wants a new token.  It doesn't know
 1734: @c what is ``inside'' the tokens (though their semantic values may reflect
 1735: @c this).  Typically the lexical analyzer makes the tokens by parsing
 1736: @c characters of text, but Bison does not depend on this.  
 1737: 
 1738: トークンは、@dfn{字句解析器(lexical analyzer)}と呼ばれる関数によって得られ、
 1739: その関数を(Cで書くような)なんらかの方法で与える必要があります。
 1740: Bison構文解析器は、新しいトークンを必要とするたびに、
 1741: 字句解析器を呼び出します。
 1742: Bison構文解析器は、トークンの「内部」がなんであるか知りません
 1743: (しかし、トークンの意味値は関係します)。
 1744: 一般に、字句解析器は、テキスト中の文字を解析してトークンを得ますが、
 1745: Bisonはその方法を知りません。
 1746: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 1747: 
 1748: @c The Bison parser file is C code which defines a function named
 1749: @c @code{yyparse} which implements that grammar.  This function does not make
 1750: @c a complete C program: you must supply some additional functions.  One is
 1751: @c the lexical analyzer.  Another is an error-reporting function which the
 1752: @c parser calls to report an error.  In addition, a complete C program must
 1753: @c start with a function called @code{main}; you have to provide this, and
 1754: @c arrange for it to call @code{yyparse} or the parser will never run.
 1755: @c @xref{Interface, ,Parser C-Language Interface}.
 1756: 
 1757: Bison構文解析器ファイルは、Cのプログラムで、@code{yyparse}という名前の、
 1758: 文法を実装する関数を定義します。
 1759: この関数は、完全なCのプログラムを構成しません。
 1760: いくつかの関数を補ってやる必要があります。
 1761: 1つは、字句解析器です。
 1762: もう1つは、エラーを報告するために構文解析器が呼び出す、
 1763: エラー報告関数です。
 1764: さらに、完全なCプログラムは@code{main}関数から実行を始める必要がありますので、
 1765: これを補って、そこから@code{yyparse}を呼び出してください。
 1766: @xref{Interface, ,Parser C-Language Interface}。
 1767: 
 1768: @c Aside from the token type names and the symbols in the actions you
 1769: @c write, all variable and function names used in the Bison parser file
 1770: @c begin with @samp{yy} or @samp{YY}.  This includes interface functions
 1771: @c such as the lexical analyzer function @code{yylex}, the error reporting
 1772: @c function @code{yyerror} and the parser function @code{yyparse} itself.
 1773: @c This also includes numerous identifiers used for internal purposes.
 1774: @c Therefore, you should avoid using C identifiers starting with @samp{yy}
 1775: @c or @samp{YY} in the Bison grammar file except for the ones defined in
 1776: @c this manual.
 1777: 
 1778: あなたが書くアクションの中でのトークンの型名と記号に関係なく、
 1779: Bison構文解析器の中で使われるすべての変数と関数の名前は、
 1780: @samp{yy}または@samp{YY}で始まります。
 1781: これは、字句解析関数@code{yylex}とエラー報告関数@code{yyerror}および
 1782: 構文解析関数@code{yyparse}のようなインターフェイス関数も含みます。
 1783: また、内部で使われる多数の識別子も同様です。
 1784: したがって、本書で定義されている場合を除いて、
 1785: Bison文法ファイルの中で@samp{yy}または@samp{YY}で始まる
 1786: Cの識別子の利用は避けるべきです。
 1787: 
 1788: 
 1789: @c =====================================================================
 1790: @node Stages, Grammar Layout, Bison Parser, Concepts
 1791: @c @section Stages in Using Bison
 1792: @section Bisonを使う手順
 1793: @cindex stages in using Bison
 1794: @cindex using Bison
 1795: @cindex 使用方法
 1796: @cindex Bisonの使用方法
 1797: 
 1798: @c The actual language-design process using Bison, from grammar specification
 1799: @c to a working compiler or interpreter, has these parts:
 1800: 
 1801: Bisonを使って、文法の定義から実際に動くコンパイラやインタープリタを作るまでの、
 1802: 言語設計手順は、次のようになります。
 1803: 
 1804: @enumerate
 1805: @item
 1806: @c Formally specify the grammar in a form recognized by Bison
 1807: @c (@pxref{Grammar File, ,Bison Grammar Files}).
 1808: @c For each grammatical rule in the language,
 1809: @c describe the action that is to be taken when an instance of that rule
 1810: @c is recognized.  The action is described by a sequence of C statements.
 1811: @c
 1812: Bisonが認識できる形式で、文法を形式的に指定します
 1813: (@pxref{Grammar File, ,Bison Grammar Files})。
 1814: 言語の各文法規則に対して、
 1815: その規則のインスタンスが認識されたときに実行される
 1816: アクションを記述します。
 1817: アクションは、C言語の文の並びで書きます。
 1818: 
 1819: @item
 1820: @c Write a lexical analyzer to process input and pass tokens to the
 1821: @c parser.  The lexical analyzer may be written by hand in C
 1822: @c (@pxref{Lexical, ,The Lexical Analyzer Function @code{yylex}}).  It could als@c o be produced using Lex, but the use
 1823: @c of Lex is not discussed in this manual.
 1824: @c
 1825: 入力を処理し、トークンを構文解析器に渡すために、字句解析器を書きます。
 1826: 字句解析器は、Cで手作業で書いてもかまいません
 1827: (@pxref{Lexical, ,The Lexical Analyzer Function @code{yylex}})。
 1828: Lexを使って生成することも可能ですが、本書ではLexの使い方については解説
 1829: していません。
 1830: 
 1831: @item
 1832: @c Write a controlling function that calls the Bison-produced parser.
 1833: @c
 1834: Bisonが生成した構文解析器を呼び出す、制御関数を書きます。
 1835: 
 1836: @item
 1837: @c Write error-reporting routines.
 1838: @c
 1839: エラー報告関数を書きます。
 1840: 
 1841: @end enumerate
 1842: 
 1843: @c To turn this source code as written into a runnable program, you
 1844: @c must follow these steps:
 1845: 
 1846: このソースプログラムを実行可能なプログラムにするために、
 1847: 次の手順が必要です。
 1848: 
 1849: @enumerate
 1850: @item
 1851: @c Run Bison on the grammar to produce the parser.
 1852: @c
 1853: 構文解析器を生成するために、Bisonを実行します。
 1854: 
 1855: @item
 1856: @c Compile the code output by Bison, as well as any other source files.
 1857: @c
 1858: Bisonが生成したソースプログラムとその他のソースプログラムを、
 1859: コンパイルします。
 1860: 
 1861: @item
 1862: @c Link the object files to produce the finished product.
 1863: @c
 1864: オブジェクトファイルをリンクして、最終的なプログラムを得ます。
 1865: 
 1866: @end enumerate
 1867: 
 1868: 
 1869: @c =====================================================================
 1870: @node Grammar Layout,  , Stages, Concepts
 1871: @c @section The Overall Layout of a Bison Grammar
 1872: @section Bison文法の全体像
 1873: @cindex grammar file
 1874: @cindex file format
 1875: @cindex format of grammar file
 1876: @cindex layout of Bison grammar
 1877: @cindex 文法ファイル
 1878: @cindex ファイル書式
 1879: 
 1880: @c The input file for the Bison utility is a @dfn{Bison grammar file}.  The
 1881: @c general form of a Bison grammar file is as follows:
 1882: 
 1883: Bisonユーティリティへの入力は、
 1884: @dfn{Bison文法ファイル(Bison grammar file)}です。
 1885: Bison文法ファイルの一般的な書式は、次のとおりです。
 1886: 
 1887: @example
 1888: %@{
 1889: @c @var{C declarations}
 1890: @var{C宣言部(C declarations)}
 1891: %@}
 1892: 
 1893: @c @var{Bison declarations}
 1894: @var{Bison宣言部(Bison declarations)}
 1895: 
 1896: %%
 1897: @c @var{Grammar rules}
 1898: @var{文法規則部(Grammar rules)}
 1899: %%
 1900: @c @var{Additional C code}
 1901: @var{追加のCプログラム部(Additional C code)}
 1902: @end example
 1903: 
 1904: @c @noindent
 1905: @c The @samp{%%}, @samp{%@{} and @samp{%@}} are punctuation that appears
 1906: @c in every Bison grammar file to separate the sections.
 1907: 
 1908: Bison文法ファイル中の@samp{%%}、@samp{%@{}、@samp{%@}}は、
 1909: ファイルを節に分ける区切り記号です。
 1910: 
 1911: @c The C declarations may define types and variables used in the actions.
 1912: @c You can also use preprocessor commands to define macros used there, and use
 1913: @c @code{#include} to include header files that do any of these things.
 1914: 
 1915: @dfn{C宣言部}では、
 1916: アクションの中で使われる型と変数を定義できます。
 1917: マクロを定義するためのプリプロセッサディレクティブや、
 1918: ヘッダファイルをインクルードするための@code{#include}命令も使用できます。
 1919: 
 1920: @c The Bison declarations declare the names of the terminal and nonterminal
 1921: @c symbols, and may also describe operator precedence and the data types of
 1922: @c semantic values of various symbols.
 1923: 
 1924: @dfn{Bison宣言部}には、終端記号、非終端記号、さらに、
 1925: 演算子の優先順位、さまざまな記号の意味値のデータ型を記述できます。
 1926: 
 1927: @c The grammar rules define how to construct each nonterminal symbol from its
 1928: @c parts.
 1929: 
 1930: @dfn{文法規則部}では、各非終端記号をその部品から組み立てる方法を
 1931: 定義します。
 1932: 
 1933: @c The additional C code can contain any C code you want to use.  Often the
 1934: @c definition of the lexical analyzer @code{yylex} goes here, plus subroutines
 1935: @c called by the actions in the grammar rules.  In a simple program, all the
 1936: @c rest of the program can go here.
 1937: 
 1938: @dfn{追加のCプログラム部}には、
 1939: あなたが望むCプログラムを記述できます。
 1940: よく字句解析関数@code{yylex}や
 1941: 文法規則の中のアクションから呼ばれる関数をここに書きます。
 1942: 単純なプログラムでは、@footnote{【訳注】他のファイルに書くのではなく}ここに
 1943: 残りのプログラム全部を書きます。
 1944: 
 1945: 
 1946: @c =====================================================================
 1947: @node Examples, Grammar File, Concepts, Top
 1948: @c @chapter Examples
 1949: @chapter 例
 1950: @cindex simple examples
 1951: @cindex examples, simple
 1952: @cindex 単純な例
 1953: @cindex 例
 1954: 
 1955: @c Now we show and explain three sample programs written using Bison: a
 1956: @c reverse polish notation calculator, an algebraic (infix) notation
 1957: @c calculator, and a multi-function calculator.  All three have been tested
 1958: @c under BSD Unix 4.3; each produces a usable, though limited, interactive
 1959: @c desk-top calculator.
 1960: 
 1961: 本章では、Bison文法を使って書いた例を3つ示します。
 1962: 逆ポーランド記法電卓、算術(中置)記法電卓、多機能電卓です。
 1963: すべてBSD UNIX 4.3上でテストしました。
 1964: 限定的ではありますが、対話的な電卓として利用可能です。
 1965: 
 1966: @c These examples are simple, but Bison grammars for real programming
 1967: @c languages are written the same way.
 1968: 
 1969: これらの例は単純ですが、現実のプログラミング言語に対する
 1970: Bison文法も、書き方は同じです。
 1971: 
 1972: @ifinfo
 1973: You can copy these examples out of the Info file and into a source file
 1974: to try them.
 1975: @end ifinfo
 1976: 
 1977: @menu
 1978: * RPN Calc::          Reverse polish notation calculator;
 1979:                         a first example with no operator precedence.
 1980: * Infix Calc::        Infix (algebraic) notation calculator.
 1981:                         Operator precedence is introduced.
 1982: * Simple Error Recovery::  Continuing after syntax errors.
 1983: * Multi-function Calc::  Calculator with memory and trig functions.
 1984:                            It uses multiple data-types for semantic values.
 1985: * Exercises::         Ideas for improving the multi-function calculator.
 1986: @end menu
 1987: 
 1988: 
 1989: @c =====================================================================
 1990: @node RPN Calc, Infix Calc,  , Examples
 1991: @c @section Reverse Polish Notation Calculator
 1992: @section 逆ポーランド記法電卓
 1993: @cindex reverse polish notation
 1994: @cindex polish notation calculator
 1995: @cindex rpcalc
 1996: @cindex calculator, simple
 1997: @cindex 逆ポーランド記法
 1998: @cindex 電卓
 1999: 
 2000: @c The first example is that of a simple double-precision @dfn{reverse polish
 2001: @c notation} calculator (a calculator using postfix operators).  This example
 2002: @c provides a good starting point, since operator precedence is not an issue.
 2003: @c The second example will illustrate how operator precedence is handled.
 2004: 
 2005: 最初の例は、@dfn{逆ポーランド記法(reverse polish notation)}を使う
 2006: 倍精度の電卓で、演算子を後に書きます。
 2007: この例は、演算子の優先順位の問題がないので、入門には適しています。
 2008: 第2の例では、演算子の優先順位をどのように扱うかを示します。
 2009: 
 2010: @c The source code for this calculator is named @file{rpcalc.y}.  The
 2011: @c @samp{.y} extension is a convention used for Bison input files.
 2012: 
 2013: この電卓のソースファイルを@file{rpcalc.y}とします。
 2014: Bisonの入力ファイルには、通常@samp{.y}という拡張子を付けます。
 2015: 
 2016: @menu
 2017: * Decls: Rpcalc Decls.  Bison and C declarations for rpcalc.
 2018: * Rules: Rpcalc Rules.  Grammar Rules for rpcalc, with explanation.
 2019: * Lexer: Rpcalc Lexer.  The lexical analyzer.
 2020: * Main: Rpcalc Main.    The controlling function.
 2021: * Error: Rpcalc Error.  The error reporting function.
 2022: * Gen: Rpcalc Gen.      Running Bison on the grammar file.
 2023: * Comp: Rpcalc Compile. Run the C compiler on the output code.
 2024: @end menu
 2025: 
 2026: 
 2027: @c =====================================================================
 2028: @node Rpcalc Decls, Rpcalc Rules,  , RPN Calc
 2029: @c @subsection Declarations for @code{rpcalc}
 2030: @subsection @code{rpcalc}のための宣言
 2031: 
 2032: @c Here are the C and Bison declarations for the reverse polish notation
 2033: @c calculator.  As in C, comments are placed between @samp{/*@dots{}*/}.
 2034: 
 2035: 逆ポーランド記法電卓のためのCとBisonの宣言を示します。
 2036: Cと同様に@samp{/*@dots{}*/}はコメントです。
 2037: 
 2038: @example
 2039: @c /* Reverse polish notation calculator. */
 2040: /* 逆ポーランド記法電卓 */
 2041: 
 2042: %@{
 2043: #define YYSTYPE double
 2044: #include <math.h>
 2045: %@}
 2046: 
 2047: %token NUM
 2048: 
 2049: @c %% /* Grammar rules and actions follow */
 2050: %% /* 文法規則とアクションが続く */
 2051: @end example
 2052: 
 2053: @c The C declarations section
 2054: @c (@pxref{C Declarations, ,The C Declarations Section}) contains two
 2055: @c preprocessor directives.
 2056: 
 2057: C宣言部(@pxref{C Declarations, ,The C Declarations Section})には、
 2058: 2つのプリプロセッサディレクティブがあります。
 2059: 
 2060: @c The @code{#define} directive defines the macro @code{YYSTYPE}, thus
 2061: @c specifying the C data type for semantic values of both tokens and groupings
 2062: @c (@pxref{Value Type, ,Data Types of Semantic Values}).
 2063: @c The Bison parser will use whatever type
 2064: @c @code{YYSTYPE} is defined as; if you don't define it, @code{int} is the
 2065: @c default.  Because we specify @code{double}, each token and each expression
 2066: @c has an associated value, which is a floating point number.
 2067: 
 2068: @code{#define}ディレクティブで、トークンとグループの意味値に対する
 2069: Cのデータ型を指定するために、マクロ@code{YYSTYPE}を定義します
 2070: (@pxref{Value Type, ,Data Types of Semantic Values})。
 2071: Bison構文解析器は、@code{YYSTYPE}に定義された型を使います。
 2072: 定義しないと、@code{int}型が使用されます。
 2073: 各トークンと式は、浮動小数点数である記録値を持つので、
 2074: ここでは@code{double}を指定します。
 2075: 
 2076: @c The @code{#include} directive is used to declare the exponentiation
 2077: @c function @code{pow}.
 2078: 
 2079: べき乗関数@code{pow}の宣言を使うために、
 2080: @code{#include}ディレクティブを使っています。
 2081: 
 2082: @c The second section, Bison declarations, provides information to Bison
 2083: @c about the token types
 2084: @c (@pxref{Bison Declarations, ,The Bison Declarations Section}).
 2085: @c Each terminal symbol that is
 2086: @c not a single-character literal must be declared here.  (Single-character
 2087: @c literals normally don't need to be declared.)  In this example, all the
 2088: @c arithmetic operators are designated by single-character literals, so the
 2089: @c only terminal symbol that needs to be declared is @code{NUM}, the token
 2090: @c type for numeric constants.
 2091: 
 2092: 第2の部、Bison宣言は、Bisonのためにトークン型についての情報を用意します
 2093: (@pxref{Bison Declarations, ,The Bison Declarations Section})。
 2094: 1文字リテラルでない終端記号は、ここで宣言する必要があります
 2095: (通常、1文字のリテラルを宣言する必要はありません)。
 2096: この例では、すべての算術演算子が1文字リテラルなので、
 2097: 数値定数に対するトークン型@code{NUM}だけを、
 2098: 終端記号として宣言します。
 2099: 
 2100: 
 2101: @c =====================================================================
 2102: @node Rpcalc Rules, Rpcalc Lexer, Rpcalc Decls, RPN Calc
 2103: @c @subsection Grammar Rules for @code{rpcalc}
 2104: @subsection @code{rpcalc}のための文法規則
 2105: 
 2106: @c Here are the grammar rules for the reverse polish notation calculator.
 2107: 
 2108: 逆ポーランド記法電卓のための文法規則を示します。
 2109: 
 2110: @example
 2111: @c input:    /* empty */
 2112: input:    /* 空 */
 2113:         | input line
 2114: ;
 2115: 
 2116: line:     '\n'
 2117:         | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
 2118: ;
 2119: 
 2120: exp:      NUM             @{ $$ = $1;         @}
 2121:         | exp exp '+'     @{ $$ = $1 + $2;    @}
 2122:         | exp exp '-'     @{ $$ = $1 - $2;    @}
 2123:         | exp exp '*'     @{ $$ = $1 * $2;    @}
 2124:         | exp exp '/'     @{ $$ = $1 / $2;    @}
 2125: @c       /* Exponentiation */
 2126:       /* べき乗関数 */
 2127:         | exp exp '^'     @{ $$ = pow ($1, $2); @}
 2128: @c      /* Unary minus    */
 2129:       /* 単項のマイナス    */
 2130:         | exp 'n'         @{ $$ = -$1;        @}
 2131: ;
 2132: %%
 2133: @end example
 2134: 
 2135: @c The groupings of the rpcalc ``language'' defined here are the expression
 2136: @c (given the name @code{exp}), the line of input (@code{line}), and the
 2137: @c complete input transcript (@code{input}).  Each of these nonterminal
 2138: @c symbols has several alternate rules, joined by the @samp{|} punctuator
 2139: @c which is read as ``or''.  The following sections explain what these rules
 2140: @c mean.
 2141: 
 2142: ここで定義されるrpcalc「言語」のグループは、
 2143: 式(@code{exp})と、入力行(@code{line})と、
 2144: 完全な入力の写し(@code{input})です。
 2145: これらの非終端記号には、「論理和」という@samp{|}記号で区切られた、
 2146: いくつかの規則があります。
 2147: 以下の項で、これらの規則の意味を説明します。
 2148: 
 2149: @c The semantics of the language is determined by the actions taken when a
 2150: @c grouping is recognized.  The actions are the C code that appears inside
 2151: @c braces.  @xref{Actions}.
 2152: 
 2153: 言語の意味は、グループが認識されたときのアクションによって決まります。
 2154: アクションとは、ブレースで囲まれたCのプログラムです。
 2155: @xref{Actions}。
 2156: 
 2157: @c You must specify these actions in C, but Bison provides the means for
 2158: @c passing semantic values between the rules.  In each action, the
 2159: @c pseudo-variable @code{$$} stands for the semantic value for the grouping
 2160: @c that the rule is going to construct.  Assigning a value to @code{$$} is the
 2161: @c main job of most actions.  The semantic values of the components of the
 2162: @c rule are referred to as @code{$1}, @code{$2}, and so on.
 2163: 
 2164: これらのアクションをCで書く必要がありますが、
 2165: Bisonには規則の間で意味値を受け渡しする方法があります。
 2166: それぞれのアクションで、擬似変数@code{$$}は、
 2167: その規則が構成しようとしているグループの意味値を示します。
 2168: @code{$$}に値を代入することが、アクションの主な仕事です。
 2169: 規則の部品の意味値は、@code{$1}、@code{$2}などの
 2170: 名前で参照されます。
 2171: 
 2172: @menu
 2173: * Rpcalc Input::      
 2174: * Rpcalc Line::       
 2175: * Rpcalc Expr::       
 2176: @end menu
 2177: 
 2178: 
 2179: @c =====================================================================
 2180: @node Rpcalc Input, Rpcalc Line,  , Rpcalc Rules
 2181: @c @subsubsection Explanation of @code{input}
 2182: @subsubsection @code{input}の説明
 2183: 
 2184: @c Consider the definition of @code{input}:
 2185: 
 2186: @code{input}の定義について考えます。
 2187: 
 2188: @example
 2189: @c input:    /* empty */
 2190: input:    /* 空 */
 2191:         | input line
 2192: ;
 2193: @end example
 2194: 
 2195: @c This definition reads as follows: ``A complete input is either an empty
 2196: @c string, or a complete input followed by an input line''.  Notice that
 2197: @c ``complete input'' is defined in terms of itself.  This definition is said
 2198: @c to be @dfn{left recursive} since @code{input} appears always as the
 2199: @c leftmost symbol in the sequence.  @xref{Recursion, ,Recursive Rules}.
 2200: 
 2201: この定義の意味は、「完全な入力とは、空文字列であるか、あるいは、
 2202: 完全な入力に入力行が続いたものである」ということです。
 2203: 「完全な入力」が、それ自身を使って定義されていることに注意してください。
 2204: 列の中で@code{input}が常に左端の記号なので、
 2205: このような定義を@dfn{左再帰(left recursive)}と呼びます。
 2206: @xref{Recursion, ,Recursive Rules}。
 2207: 
 2208: @c The first alternative is empty because there are no symbols between the
 2209: @c colon and the first @samp{|}; this means that @code{input} can match an
 2210: @c empty string of input (no tokens).  We write the rules this way because it
 2211: @c is legitimate to type @kbd{Ctrl-d} right after you start the calculator.
 2212: @c It's conventional to put an empty alternative first and write the comment
 2213: @c @samp{/* empty */} in it.
 2214: 
 2215: 最初の選択肢は、@samp{:}と@samp{|}の間に記号がないので空です。
 2216: これは、(トークンを含まない)空の入力文字列にマッチします。
 2217: 電卓を起動した直後に@kbd{Ctrl-d} @footnote{【訳注】UNIXの標準的なコンソールの
 2218: 設定で、入力の終わりを示す制御文字で、MS-DOSでは代わりに@kbd{Ctrl-z}。}を
 2219: 押しても、正しい入力と扱われるように、この規則を入れました。
 2220: 通常、空に対応する選択肢を最初に置き、そこに@samp{/* 空 */}と
 2221: 書きます。
 2222: 
 2223: @c The second alternate rule (@code{input line}) handles all nontrivial input.
 2224: @c It means, ``After reading any number of lines, read one more line if
 2225: @c possible.''  The left recursion makes this rule into a loop.  Since the
 2226: @c first alternative matches empty input, the loop can be executed zero or
 2227: @c more times.
 2228: 
 2229: 2つめの選択肢である規則(@code{input line})は、
 2230: 自明(空)でないすべての入力を扱います。
 2231: その意味は、「任意の数の行を読み込んだ後で、もし可能ならば、
 2232: もう1行読み込む」ということです。
 2233: 左再帰が、この規則を繰り返しにします。
 2234: 最初の選択肢が空の入力にマッチするので、
 2235: 0回以上任意の回数の繰り返しになります。
 2236: 
 2237: @c The parser function @code{yyparse} continues to process input until a
 2238: @c grammatical error is seen or the lexical analyzer says there are no more
 2239: @c input tokens; we will arrange for the latter to happen at end of file.
 2240: 
 2241: 構文解析器関数@code{yyparse}は、文法エラーが発生するか、あるいは、
 2242: 字句解析器がもうトークンがないと判定するまで、
 2243: 入力の処理を続けます。
 2244: ファイルの終わりで起きることについては、後で考慮します。
 2245: 
 2246: 
 2247: @c =====================================================================
 2248: @node Rpcalc Line, Rpcalc Expr, Rpcalc Input, Rpcalc Rules
 2249: @c @subsubsection Explanation of @code{line}
 2250: @subsubsection @code{line}の説明
 2251: 
 2252: @c Now consider the definition of @code{line}:
 2253: 
 2254: 次に、@code{line}の定義について考えます。
 2255: 
 2256: @example
 2257: line:     '\n'
 2258:         | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
 2259: ;
 2260: @end example
 2261: 
 2262: @c The first alternative is a token which is a newline character; this means
 2263: @c that rpcalc accepts a blank line (and ignores it, since there is no
 2264: @c action).  The second alternative is an expression followed by a newline.
 2265: @c This is the alternative that makes rpcalc useful.  The semantic value of
 2266: @c the @code{exp} grouping is the value of @code{$1} because the @code{exp} in
 2267: @c question is the first symbol in the alternative.  The action prints this
 2268: @c value, which is the result of the computation the user asked for.
 2269: 
 2270: 最初の選択肢は、改行文字であるトークンです。
 2271: これは、rpcalcが空行を受け入れ、それに対応するアクションがないので、
 2272: 無視することを示します。
 2273: 第2の選択肢は、式の後に改行が続いたものです。
 2274: これが、rpcalcを有用にする選択肢です。
 2275: 問い合わせの中の@code{exp}が、この選択肢に現れる最初の記号なので、
 2276: @code{exp}グループの意味値は、@code{$1}の値です。
 2277: アクションは、問い合わされた計算の結果である、
 2278: この値を表示します。
 2279: 
 2280: @c This action is unusual because it does not assign a value to @code{$$}.  As
 2281: @c a consequence, the semantic value associated with the @code{line} is
 2282: @c uninitialized (its value will be unpredictable).  This would be a bug if
 2283: @c that value were ever used, but we don't use it: once rpcalc has printed the
 2284: @c value of the user's input line, that value is no longer needed.
 2285: 
 2286: このアクションは、値を@code{$$}に代入しないので、例外的です。
 2287: したがって、@code{line}に対応する意味値は、初期化されず、
 2288: その値は予想できなくなります。
 2289: もし、その値が使われると、この仕様はバグになりますが、われわれはこの値を使い
 2290: ません。ユーザーが入力した行に対する値を表示したら、
 2291: その値はもはや必要ありません。
 2292: 
 2293: 
 2294: @c =====================================================================
 2295: @node Rpcalc Expr,  , Rpcalc Line, Rpcalc Rules
 2296: @c @subsubsection Explanation of @code{expr}
 2297: @subsubsection @code{expr}の説明
 2298: 
 2299: @c The @code{exp} grouping has several rules, one for each kind of expression.
 2300: @c The first rule handles the simplest expressions:
 2301: @c those that are just numbers.
 2302: @c The second handles an addition-expression, which looks like two expressions
 2303: @c followed by a plus-sign.  The third handles subtraction, and so on.
 2304: 
 2305: @code{exp}グループは、いくつかの規則を持ち、
 2306: それぞれが式の種類に対応しています。
 2307: 最初の規則は、数値そのものであるもっとも単純な式を処理します。
 2308: 第2の規則は、2個の式に加算記号が続くような、加算式を処理します。
 2309: 第3の規則は、減算式を処理する、といった具合です。
 2310: 
 2311: @example
 2312: exp:      NUM
 2313:         | exp exp '+'     @{ $$ = $1 + $2;    @}
 2314:         | exp exp '-'     @{ $$ = $1 - $2;    @}
 2315:         @dots{}
 2316:         ;
 2317: @end example
 2318: 
 2319: @c We have used @samp{|} to join all the rules for @code{exp}, but we could
 2320: @c equally well have written them separately:
 2321: 
 2322: すべての@code{exp}規則をまとめるために@samp{|}を使っていますが、
 2323: 次のように別々に書くことも可能です。
 2324: 
 2325: @example
 2326: exp:      NUM ;
 2327: exp:      exp exp '+'     @{ $$ = $1 + $2;    @} ;
 2328: exp:      exp exp '-'     @{ $$ = $1 - $2;    @} ;
 2329:         @dots{}
 2330: @end example
 2331: 
 2332: @c Most of the rules have actions that compute the value of the expression in
 2333: @c terms of the value of its parts.  For example, in the rule for addition,
 2334: @c @code{$1} refers to the first component @code{exp} and @code{$2} refers to
 2335: @c the second one.  The third component, @code{'+'}, has no meaningful
 2336: @c associated semantic value, but if it had one you could refer to it as
 2337: @c @code{$3}.  When @code{yyparse} recognizes a sum expression using this
 2338: @c rule, the sum of the two subexpressions' values is produced as the value of
 2339: @c the entire expression.  @xref{Actions}.
 2340: 
 2341: 規則のほとんどは、式の部品の値から式の値を計算するための、
 2342: アクションを持っています。
 2343: たとえば、加算のための規則では、@code{$1}は式の第1の部品を、
 2344: @code{$2}は式の第2の部品を表します。
 2345: 第3の部品@code{'+'}は、意味値には関連する情報を持ちませんが、
 2346: もし値を持っていれば、@code{$3}として参照できます。
 2347: @code{yyparse}がこの規則を使って加算式を認識すると、
 2348: 式全体の値として、2個の部分式の値の和が生成されます。
 2349: @xref{Actions}。
 2350: 
 2351: @c You don't have to give an action for every rule.  When a rule has no
 2352: @c action, Bison by default copies the value of @code{$1} into @code{$$}.
 2353: @c This is what happens in the first rule (the one that uses @code{NUM}).
 2354: 
 2355: すべての規則に対してアクションを書く必要はありません。
 2356: アクションを省略すると、Bisonは@code{$1}の値を@code{$$}に複写します。
 2357: 第1の規則では、@code{NUM}の値をそのまま複写するために、
 2358: このようになっています。
 2359: 
 2360: @c The formatting shown here is the recommended convention, but Bison does
 2361: @c not require it.  You can add or change whitespace as much as you wish.
 2362: @c For example, this:
 2363: 
 2364: ここで示したリストは、望ましい書式ですが、
 2365: Bisonがこのように要求するわけではありません。
 2366: 必要に応じて、空白、タブ、改行を置けます。
 2367: 次のような書き方も可能です。
 2368: 
 2369: @example
 2370: exp   : NUM | exp exp '+' @{$$ = $1 + $2; @} | @dots{}
 2371: @end example
 2372: 
 2373: @c @noindent
 2374: @c means the same thing as this:
 2375: 
 2376: これは、次のリストと等価です。
 2377: 
 2378: @example
 2379: exp:      NUM
 2380:         | exp exp '+'    @{ $$ = $1 + $2; @}
 2381:         | @dots{}
 2382: @end example
 2383: 
 2384: @c @noindent
 2385: @c The latter, however, is much more readable.
 2386: 
 2387: しかし、後者のほうが可読性が優れています。
 2388: 
 2389: 
 2390: @c =====================================================================
 2391: @node Rpcalc Lexer, Rpcalc Main, Rpcalc Rules, RPN Calc
 2392: @c @subsection The @code{rpcalc} Lexical Analyzer
 2393: @subsection @code{rpcalc}字句解析器
 2394: @cindex writing a lexical analyzer
 2395: @cindex lexical analyzer, writing
 2396: @cindex 字句解析器
 2397: 
 2398: @c The lexical analyzer's job is low-level parsing: converting characters or
 2399: @c sequences of characters into tokens.  The Bison parser gets its tokens by
 2400: @c calling the lexical analyzer.
 2401: @c @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}.
 2402: 
 2403: 字句解析器の仕事は、低水準の構文解析で、文字または文字列を
 2404: トークンに変換します。
 2405: Bison構文解析器は、字句解析器を呼び出してトークンを得ます。
 2406: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 2407: 
 2408: @c Only a simple lexical analyzer is needed for the RPN calculator.  This
 2409: @c lexical analyzer skips blanks and tabs, then reads in numbers as
 2410: @c @code{double} and returns them as @code{NUM} tokens.  Any other character
 2411: @c that isn't part of a number is a separate token.  Note that the token-code
 2412: @c for such a single-character token is the character itself.
 2413: 
 2414: RPN(逆ポーランド記法)電卓には、簡単な字句解析器のみが必要です。
 2415: この字句解析器は、空白とタブを読み飛ばし、
 2416: 数値を読み込んで@code{double}型の@code{NUM}トークンとして返します。
 2417: 数値の一部分ではないその他の文字は、独立のトークンです。
 2418: 1文字トークンのトークン符号はその文字自身であることに注意してください。
 2419: 
 2420: @c The return value of the lexical analyzer function is a numeric code which
 2421: @c represents a token type.  The same text used in Bison rules to stand for
 2422: @c this token type is also a C expression for the numeric code for the type.
 2423: @c This works in two ways.  If the token type is a character literal, then its
 2424: @c numeric code is the ASCII code for that character; you can use the same
 2425: @c character literal in the lexical analyzer to express the number.  If the
 2426: @c token type is an identifier, that identifier is defined by Bison as a C
 2427: @c macro whose definition is the appropriate number.  In this example,
 2428: @c therefore, @code{NUM} becomes a macro for @code{yylex} to use.
 2429: 
 2430: 字句解析関数の戻り値は、トークン型を表す数値です。
 2431: Bison規則の中でトークン型を表すために使われる文字列と同じものが、
 2432: その型の数値符号を表すCの式でもあります。
 2433: これには、2種類の働きがあります。
 2434: もし、トークン型が文字リテラルならば、
 2435: その数値符号は文字のASCII符号であり、
 2436: 数値を表すために字句解析器の中と同じ文字リテラルを使えます。
 2437: もし、トークン型が識別子ならば、適切な番号を定義するCのマクロとして、
 2438: その識別子がBisonによって定義されます。
 2439: したがって、この例では、@code{NUM}は、@code{yylex}のために使える
 2440: マクロにもなります。
 2441: 
 2442: @c The semantic value of the token (if it has one) is stored into the global
 2443: @c variable @code{yylval}, which is where the Bison parser will look for it.
 2444: @c (The C data type of @code{yylval} is @code{YYSTYPE}, which was defined
 2445: @c at the beginning of the grammar;
 2446: @c @pxref{Rpcalc Decls, ,Declarations for @code{rpcalc}}.)
 2447: 
 2448: トークンの意味値は、もし存在すれば、大域変数@code{yylval}に記憶され、
 2449: Bison構文解析器はそこを見にいきます
 2450: (@code{yylval}のCデータ型は、文法の最初で定義される@code{YYSTYPE}です。
 2451: @pxref{Rpcalc Decls, ,Declarations for @code{rpcalc}})。
 2452: 
 2453: @c A token type code of zero is returned if the end-of-file is encountered.
 2454: @c (Bison recognizes any nonpositive value as indicating the end of the
 2455: @c input.)
 2456: 
 2457: ファイルの終わりに達すると、トークン型のコード0が返されます
 2458: (Bisonは、正でない任意の値を入力の終わりと認識します)。
 2459: 
 2460: @c Here is the code for the lexical analyzer:
 2461: 
 2462: 字句解析器のプログラムの例を示します。
 2463: 
 2464: @example
 2465: @group
 2466: @c /* Lexical analyzer returns a double floating point 
 2467: @c    number on the stack and the token NUM, or the ASCII
 2468: @c    character read if not a number.  Skips all blanks
 2469: @c    and tabs, returns 0 for EOF. */
 2470: /*
 2471:  * 字句解析器は、数値を読めば、double型の値をスタックに積んで
 2472:  * トークン「NUM」を返し、数値以外を読めば、その文字のアスキー符号を返す。
 2473:  * 空白とタブは読み飛ばされる。ファイルが終わると0を返す。
 2474:  */
 2475: 
 2476: #include <ctype.h>
 2477: @end group
 2478: 
 2479: @group
 2480: yylex ()
 2481: @{
 2482:   int c;
 2483: 
 2484: @c   /* skip white space  */
 2485:   /* 空白類を読み飛ばす  */
 2486:   while ((c = getchar ()) == ' ' || c == '\t')  
 2487:     ;
 2488: @end group
 2489: @group
 2490: @c  /* process numbers   */
 2491:   /* 数値を処理する   */
 2492:   if (c == '.' || isdigit (c))                
 2493:     @{
 2494:       ungetc (c, stdin);
 2495:       scanf ("%lf", &yylval);
 2496:       return NUM;
 2497:     @}
 2498: @end group
 2499: @group
 2500:   /* ファイルの終わりを処理する  */
 2501:   if (c == EOF)                            
 2502:     return 0;
 2503:   /* 1文字を返す */
 2504:   return c;                                
 2505: @}
 2506: @end group
 2507: @end example
 2508: 
 2509: 
 2510: @c =====================================================================
 2511: @node Rpcalc Main, Rpcalc Error, Rpcalc Lexer, RPN Calc
 2512: @c @subsection The Controlling Function
 2513: @subsection 制御関数
 2514: @cindex controlling function
 2515: @cindex main function in simple example
 2516: @cindex 制御関数
 2517: @cindex 単純な例のmain関数
 2518: @cindex main関数
 2519: 
 2520: @c In keeping with the spirit of this example, the controlling function is
 2521: @c kept to the bare minimum.  The only requirement is that it call
 2522: @c @code{yyparse} to start the process of parsing.
 2523: 
 2524: この例の精神に則って、制御関数は、飾りのない最小限のものです。
 2525: 唯一必要なことは、構文解析の処理を始めるために、
 2526: @code{yyparse}関数を呼び出すことです。
 2527: 
 2528: @example
 2529: @group
 2530: main ()
 2531: @{
 2532:   yyparse ();
 2533: @}
 2534: @end group
 2535: @end example
 2536: 
 2537: @footnote{【訳注】古いK&R-C処理系を使う場合には前述の例のままでよいのですが、
 2538: ANSI-C処理系を使う場合には、@code{main}関数が返す値が
 2539: @code{int}型なので、次のように書くべきです。
 2540: 他の関数についても同様です。本書の例のすべては古い書式で書かれています。
 2541: 
 2542: @example
 2543: @group
 2544: int main ()
 2545: @{
 2546:   return yyparse ();
 2547: @}
 2548: @end group
 2549: @end example
 2550: }
 2551: 
 2552: @c =====================================================================
 2553: @node Rpcalc Error, Rpcalc Gen, Rpcalc Main, RPN Calc
 2554: @c @subsection The Error Reporting Routine
 2555: @subsection エラー報告関数
 2556: @cindex error reporting routine
 2557: @cindex エラー報告関数
 2558: 
 2559: @c When @code{yyparse} detects a syntax error, it calls the error reporting
 2560: @c function @code{yyerror} to print an error message (usually but not always
 2561: @c @code{"parse error"}).  It is up to the programmer to supply @code{yyerror}
 2562: @c (@pxref{Interface, ,Parser C-Language Interface}),
 2563: @c so here is the definition we will use:
 2564: 
 2565: @code{yyparse}は、構文エラーを検出すると、エラーメッセージ
 2566: (必ずそうとはかぎりませんが、通常は@code{"parse error"})を
 2567: 表示するために、エラー報告関数@code{yyerror}を呼び出します。
 2568: 
 2569: @example
 2570: @group
 2571: #include <stdio.h>
 2572: 
 2573: @c yyerror (s)  /* Called by yyparse on error */
 2574: yyerror (s)  /* エラーが起きるとyyparseから呼び出される */
 2575:      char *s;
 2576: @{
 2577:   printf ("%s\n", s);
 2578: @}
 2579: @end group
 2580: @end example
 2581: 
 2582: @c After @code{yyerror} returns, the Bison parser may recover from the error
 2583: @c and continue parsing if the grammar contains a suitable error rule
 2584: @c (@pxref{Error Recovery}).  Otherwise, @code{yyparse} returns nonzero.  We
 2585: @c have not written any error rules in this example, so any invalid input will
 2586: @c cause the calculator program to exit.  This is not clean behavior for a
 2587: @c real calculator, but it is adequate in the first example.
 2588: 
 2589: @code{yyerror}から戻った後に、Bison構文解析器は、
 2590: 文法に適切なエラー規則(@pxref{Error Recovery})があれば、
 2591: エラーから回復し、解析を継続できます。
 2592: そうでない場合には、@code{yyparse}が0でない値を返します。
 2593: この例では、エラー規則を書いていないので、
 2594: 不正な入力はすべて電卓プログラムを終了させます。
 2595: これは、実際の電卓としてはきれいな動作ではありませんが、
 2596: 最初の例としては十分です。
 2597: 
 2598: 
 2599: @c =====================================================================
 2600: @node Rpcalc Gen, Rpcalc Compile, Rpcalc Error, RPN Calc
 2601: @c @subsection Running Bison to Make the Parser
 2602: @subsection 構文解析器を生成するためにBisonを実行
 2603: @cindex running Bison (introduction)
 2604: @cindex Bisonの実行
 2605: 
 2606: @c Before running Bison to produce a parser, we need to decide how to arrange
 2607: @c all the source code in one or more source files.  For such a simple example,
 2608: @c the easiest thing is to put everything in one file.  The definitions of
 2609: @c @code{yylex}, @code{yyerror} and @code{main} go at the end, in the
 2610: @c ``additional C code'' section of the file
 2611: @c (@pxref{Grammar Layout, ,The Overall Layout of a Bison Grammar}).
 2612: 
 2613: 構文解析器を生成するためにBisonを実行する前に、
 2614: 1つ以上のソースファイルのすべてをどのように整えるか、
 2615: 決める必要があります。
 2616: このような単純な例では、すべてを1個のファイルに詰め込む方法が
 2617: いちばん簡単です。
 2618: @code{yylex}、@code{yyerror}、@code{main}の定義を、
 2619: ファイルの「追加のCコード」部の最後に置きます
 2620: (@pxref{Grammar Layout, ,The Overall Layout of a Bison Grammar})。
 2621: 
 2622: @c For a large project, you would probably have several source files, and use
 2623: @c @code{make} to arrange to recompile them.
 2624: 
 2625: 大きなプロジェクトでは、ソースコードを複数のファイルに分け、
 2626: まとめてリコンパイルするために@code{make}を使うでしょう。
 2627: 
 2628: @c With all the source in a single file, you use the following command to
 2629: @c convert it into a parser file:
 2630: 
 2631: 1つのファイルにすべてのソースが入っているならば、
 2632: 次のコマンドで、それを構文解析器ファイルに変換できます。
 2633: 
 2634: @example
 2635: bison @var{file_name}.y
 2636: @end example
 2637: 
 2638: @c @noindent
 2639: @c In this example the file was called @file{rpcalc.y} (for ``Reverse Polish
 2640: @c CALCulator'').  Bison produces a file named @file{@var{file_name}.tab.c},
 2641: @c removing the @samp{.y} from the original file name. The file output by
 2642: @c Bison contains the source code for @code{yyparse}.  The additional
 2643: @c functions in the input file (@code{yylex}, @code{yyerror} and @code{main})
 2644: @c are copied verbatim to the output.
 2645: 
 2646: この例では、ファイルは@file{rpcalc.y}(逆ポーランド記法電卓)と
 2647: 呼ばれています。Bisonは、元のファイル名から@samp{.y}を取り除いて、
 2648: @file{@var{file_name}.tab.c}というファイルを生成します。
 2649: Bisonが出力したファイルには、@code{yyparse}のソースコードが含まれています。
 2650: 入力ファイル中の追加の関数(@code{yylex}、@code{yyerror}、@code{main})は、
 2651: 出力にそのまま複写されます。
 2652: 
 2653: 
 2654: @c =====================================================================
 2655: @node Rpcalc Compile,  , Rpcalc Gen, RPN Calc
 2656: @c @subsection Compiling the Parser File
 2657: @subsection 構文解析器ファイルのコンパイル
 2658: @cindex compiling the parser
 2659: @cindex コンパイル
 2660: 
 2661: @c Here is how to compile and run the parser file:
 2662: 
 2663: 構文解析器ファイルをコンパイルする方法を示します。
 2664: @footnote{【訳注】UNIX上で@code{cc}コマンドを使ってコンパイルする方法を示します。}
 2665: 
 2666: @example
 2667: @group
 2668: @c # @r{List files in current directory.}
 2669: # @r{カレントディレクトリのファイルの一覧を見る。}
 2670: % ls
 2671: rpcalc.tab.c  rpcalc.y
 2672: @end group
 2673: 
 2674: @group
 2675: @c # @r{Compile the Bison parser.}
 2676: # @r{Bison構文解析器をコンパイルする。}
 2677: @c # @r{@samp{-lm} tells compiler to search math library for @code{pow}.}
 2678: # @r{数学ライブラリ内の@code{pow}関数をリンクするために@samp{-lm}を指定する。}
 2679: % cc rpcalc.tab.c -lm -o rpcalc
 2680: @end group
 2681: 
 2682: @group
 2683: @c # @r{List files again.}
 2684: # @r{再び、ファイルの一覧を見る。}
 2685: % ls
 2686: rpcalc  rpcalc.tab.c  rpcalc.y
 2687: @end group
 2688: @end example
 2689: 
 2690: @c The file @file{rpcalc} now contains the executable code.  Here is an
 2691: @c example session using @code{rpcalc}.
 2692: 
 2693: できた@file{rpcalc}ファイルは、実行可能プログラムです。
 2694: @code{rpcalc}を実行させる例を示します。
 2695: 
 2696: @example
 2697: % rpcalc
 2698: 4 9 +
 2699: 13
 2700: 3 7 + 3 4 5 *+-
 2701: -13
 2702: @c 3 7 + 3 4 5 * + - n              @r{Note the unary minus, @samp{n}}
 2703: 3 7 + 3 4 5 * + - n              @r{単項マイナスを示す@samp{n}に注意}
 2704: 13
 2705: 5 6 / 4 n +
 2706: -3.166666667
 2707: @c 3 4 ^                            @r{Exponentiation}
 2708: 3 4 ^                            @r{べき乗関数}
 2709: 81
 2710: @c ^D                               @r{End-of-file indicator}
 2711: ^D                               @r{入力の終わり}
 2712: %
 2713: @end example
 2714: 
 2715: 
 2716: @c =====================================================================
 2717: @node Infix Calc, Simple Error Recovery, RPN Calc, Examples
 2718: @c @section Infix Notation Calculator: @code{calc}
 2719: @section 中間記法電卓:@code{calc}
 2720: @cindex infix notation calculator
 2721: @cindex calc
 2722: @cindex calculator, infix notation
 2723: @cindex 中間記法
 2724: 
 2725: @c We now modify rpcalc to handle infix operators instead of postfix.  Infix
 2726: @c notation involves the concept of operator precedence and the need for
 2727: @c parentheses nested to arbitrary depth.  Here is the Bison code for
 2728: @c @file{calc.y}, an infix desk-top calculator.
 2729: 
 2730: 後置記法演算子に代わって中間記法演算子を扱うように
 2731: rpcalcを変更します。
 2732: 中間記法には、演算子の優先順位の概念と、
 2733: 適切な深さに入れ子できるかっこが必要です。
 2734: 中間記法電卓を作るためのBisonソースファイル
 2735: @file{calc.y}を示します。
 2736: 
 2737: @example
 2738: @c /* Infix notation calculator--calc */
 2739: /* 中間記法電卓 -- calc */
 2740: 
 2741: %@{
 2742: #define YYSTYPE double
 2743: #include <math.h>
 2744: %@}
 2745: 
 2746: @c /* BISON Declarations */
 2747: /* BISON宣言 */
 2748: %token NUM
 2749: %left '-' '+'
 2750: %left '*' '/'
 2751: @c %left NEG     /* negation--unary minus */
 2752: %left NEG     /* negation--単項マイナス */
 2753: @c %right '^'    /* exponentiation        */
 2754: %right '^'    /* べき乗関数        */
 2755: 
 2756: @c /* Grammar follows */
 2757: /* 文法規則が続く */
 2758: %%
 2759: @c input:    /* empty string */
 2760: input:    /* 空文字列 */
 2761:         | input line
 2762: ;
 2763: 
 2764: line:     '\n'
 2765:         | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
 2766: ;
 2767: 
 2768: exp:      NUM                @{ $$ = $1;         @}
 2769:         | exp '+' exp        @{ $$ = $1 + $3;    @}
 2770:         | exp '-' exp        @{ $$ = $1 - $3;    @}
 2771:         | exp '*' exp        @{ $$ = $1 * $3;    @}
 2772:         | exp '/' exp        @{ $$ = $1 / $3;    @}
 2773:         | '-' exp  %prec NEG @{ $$ = -$2;        @}
 2774:         | exp '^' exp        @{ $$ = pow ($1, $3); @}
 2775:         | '(' exp ')'        @{ $$ = $2;         @}
 2776: ;
 2777: %%
 2778: @end example
 2779: 
 2780: @c @noindent
 2781: @c The functions @code{yylex}, @code{yyerror} and @code{main} can be the same
 2782: @c as before.
 2783: 
 2784: @code{yylex}、@code{yyerror}、@code{main}関数は、
 2785: 前の例のものと同じです。
 2786: 
 2787: @c There are two important new features shown in this code.
 2788: 
 2789: このプログラムには、2つの重要な特徴があります。
 2790: 
 2791: @c In the second section (Bison declarations), @code{%left} declares token
 2792: @c types and says they are left-associative operators.  The declarations
 2793: @c @code{%left} and @code{%right} (right associativity) take the place of
 2794: @c @code{%token} which is used to declare a token type name without
 2795: @c associativity.  (These tokens are single-character literals, which
 2796: @c ordinarily don't need to be declared.  We declare them here to specify
 2797: @c the associativity.)
 2798: 
 2799: 第2の部分(Bison宣言部)では、
 2800: @code{%left}がトークンの型とそれが左結合演算子であると宣言します。
 2801: 宣言@code{%left}と@code{%right}(右結合演算子)は、
 2802: 結合性を持たないトークン型名を宣言するために使われる@code{%token}の代わりに
 2803: なります
 2804: (1文字のリテラルであるトークンは、通常、宣言する必要がありません。
 2805: ここでは、結合性を宣言します)。
 2806: 
 2807: @c Operator precedence is determined by the line ordering of the
 2808: @c declarations; the higher the line number of the declaration (lower on
 2809: @c the page or screen), the higher the precedence.  Hence, exponentiation
 2810: @c has the highest precedence, unary minus (@code{NEG}) is next, followed
 2811: @c by @samp{*} and @samp{/}, and so on.
 2812: @c @xref{Precedence, ,Operator Precedence}.
 2813: 
 2814: 演算子の優先順位は、宣言が書かれる行の順序で決まります。
 2815: 後から宣言された演算子ほど、高い優先順位を持ちます。
 2816: したがって、べき乗の優先順位がもっとも高く、
 2817: 単項の負(@code{NEG})、「@samp{*}」と「@samp{/}」と続きます。
 2818: @xref{Precedence, ,Operator Precedence}。
 2819: 
 2820: @c The other important new feature is the @code{%prec} in the grammar section
 2821: @c for the unary minus operator.  The @code{%prec} simply instructs Bison that
 2822: @c the rule @samp{| '-' exp} has the same precedence as @code{NEG}---in this
 2823: @c case the next-to-highest.
 2824: @c @xref{Contextual Precedence, ,Context-Dependent Precedence}.
 2825: 
 2826: もう1つの重要な特徴は、単項の負の演算子のために文法部分にある
 2827: @code{%prec}です。
 2828: @code{%prec}は、単純にBisonに対して、規則@samp{| '-' exp}は
 2829: @code{NEG}と同じ優先順位を持つように指示し、
 2830: この例ではどちらも2番目に高い優先順位を持ちます。
 2831: 
 2832: @c Here is a sample run of @file{calc.y}:
 2833: 
 2834: 以下は@file{calc.y}の実行例です。
 2835: 
 2836: @need 500
 2837: @example
 2838: % calc
 2839: 4 + 4.5 - (34/(8*3+-3))
 2840: 6.880952381
 2841: -56 + 2
 2842: -54
 2843: 3 ^ 2
 2844: 9
 2845: @end example
 2846: 
 2847: 
 2848: @c =====================================================================
 2849: @node Simple Error Recovery, Multi-function Calc, Infix Calc, Examples
 2850: @c @section Simple Error Recovery
 2851: @section 単純なエラー回復
 2852: @cindex error recovery, simple
 2853: @cindex エラー回復
 2854: 
 2855: @c Up to this point, this manual has not addressed the issue of @dfn{error
 2856: @c recovery}---how to continue parsing after the parser detects a syntax
 2857: @c error.  All we have handled is error reporting with @code{yyerror}.  Recall
 2858: @c that by default @code{yyparse} returns after calling @code{yyerror}.  This
 2859: @c means that an erroneous input line causes the calculator program to exit.
 2860: @c Now we show how to rectify this deficiency.
 2861: 
 2862: 今まで、本書では、@dfn{エラー回復(error recovery)}、
 2863: つまり、構文エラーを検出した後で構文解析を続ける方法については
 2864: 言及していませんでした。
 2865: 今までに扱ったことは、@code{yyerror}を使ってエラーを報告することだけでした。
 2866: @code{yyerror}を呼び出した後で、特に指定しないと@code{yyparse}は
 2867: 処理を終わることを思い出してください。
 2868: つまり、エラーを含む入力行が、電卓プログラムを終了させます。
 2869: この欠陥をどのように改善するか示しましょう。
 2870: 
 2871: @c The Bison language itself includes the reserved word @code{error}, which
 2872: @c may be included in the grammar rules.  In the example below it has
 2873: @c been added to one of the alternatives for @code{line}:
 2874: 
 2875: Bison言語の文法規則には、予約語@code{error}があります。
 2876: 次の例では、@code{line}に対する選択肢群に@code{error}を追加する
 2877: 方法を示します。
 2878: 
 2879: @example
 2880: @group
 2881: line:     '\n'
 2882:         | exp '\n'   @{ printf ("\t%.10g\n", $1); @}
 2883:         | error '\n' @{ yyerrok;                  @}
 2884: ;
 2885: @end group
 2886: @end example
 2887: 
 2888: @c This addition to the grammar allows for simple error recovery in the event
 2889: @c of a parse error.  If an expression that cannot be evaluated is read, the
 2890: @c error will be recognized by the third rule for @code{line}, and parsing
 2891: @c will continue.  (The @code{yyerror} function is still called upon to print
 2892: @c its message as well.)  The action executes the statement @code{yyerrok}, a
 2893: @c macro defined automatically by Bison; its meaning is that error recovery is
 2894: @c complete (@pxref{Error Recovery}).  Note the difference between
 2895: @c @code{yyerrok} and @code{yyerror}; neither one is a misprint.@refill
 2896: 
 2897: 文法へのこの追加によって、構文解析エラーが発生した場合に、
 2898: 簡単なエラー回復が可能になります。
 2899: 評価不可能な式が読み込まれると、
 2900: @code{line}に対する第3の規則によってエラーが認識され、
 2901: 構文解析が続けられます。
 2902: この場合にも、関数@code{yyerror}は呼び出され、
 2903: メッセージを表示します。
 2904: アクションは、
 2905: Bisonによって自動的に定義されるマクロである@code{yyerrok}文を実行します。
 2906: これはエラー回復の完了を意味します(@pxref{Error Recovery})。
 2907: @code{yyerrok}と@code{yyerror}の違いに注意してください。
 2908: 
 2909: @c This form of error recovery deals with syntax errors.  There are other
 2910: @c kinds of errors; for example, division by zero, which raises an exception
 2911: @c signal that is normally fatal.  A real calculator program must handle this
 2912: @c signal and use @code{longjmp} to return to @code{main} and resume parsing
 2913: @c input lines; it would also have to discard the rest of the current line of
 2914: @c input.  We won't discuss this issue further because it is not specific to
 2915: @c Bison programs.
 2916: 
 2917: この形式のエラー回復は、構文エラーを扱います。
 2918: 他の種類のエラーもあります。
 2919: たとえば、0による除算は、例外シグナルを発生し、通常は致命的です。
 2920: 実際の電卓プログラムは、このシグナルをつかまえて、@code{longjmp}を使って
 2921: @code{main}に戻り、入力行の構文解析を続ける必要があります。
 2922: さらに、現在の入力行の残りは破棄されるべきです。
 2923: しかし、これらの問題は、Bisonのプログラムに固有の問題ではないので、
 2924: 本書では解説しません。
 2925: 
 2926: 
 2927: @c =====================================================================
 2928: @node Multi-function Calc, Exercises, Simple Error Recovery, Examples
 2929: @c @section Multi-Function Calculator: @code{mfcalc}
 2930: @section 多機能電卓:@code{mfcalc}
 2931: @cindex multi-function calculator
 2932: @cindex mfcalc
 2933: @cindex calculator, multi-function
 2934: @cindex 多機能電卓
 2935: @cindex 電卓, 多機能
 2936: 
 2937: @c Now that the basics of Bison have been discussed, it is time to move on to
 2938: @c a more advanced problem.  The above calculators provided only five
 2939: @c functions, @samp{+}, @samp{-}, @samp{*}, @samp{/} and @samp{^}.  It would
 2940: @c be nice to have a calculator that provides other mathematical functions such
 2941: @c as @code{sin}, @code{cos}, etc.
 2942: 
 2943: Bisonの基礎についての説明が終わったので、より高度な話題に移りましょう。
 2944: 前述の電卓は、5種類の機能、@samp{+}、@samp{-}、@samp{*}、@samp{/}、
 2945: @samp{^}を持っています。
 2946: この電卓に、その他の数学関数、たとえば、@code{sin}、@code{cos}などを
 2947: 追加するとよいでしょう。
 2948: 
 2949: @c It is easy to add new operators to the infix calculator as long as they are
 2950: @c only single-character literals.  The lexical analyzer @code{yylex} passes
 2951: @c back all non-number characters as tokens, so new grammar rules suffice for
 2952: @c adding a new operator.  But we want something more flexible: built-in
 2953: @c functions whose syntax has this form:
 2954: 
 2955: 中間記法電卓への新しい演算子の追加は、
 2956: その演算子が1文字リテラルならば簡単です。
 2957: 字句解析器@code{yylex}は、数値以外のすべての文字をトークンとして渡すので、
 2958: 追加の演算子に対応する文法規則を追加するだけです。
 2959: しかし、次のような表記方法の、より柔軟な組み込み関数が必要です。
 2960: 
 2961: @example
 2962: @c @var{function_name} (@var{argument})
 2963: @var{関数名} (@var{引数})
 2964: @end example
 2965: 
 2966: @c @noindent
 2967: @c At the same time, we will add memory to the calculator, by allowing you
 2968: @c to create named variables, store values in them, and use them later.
 2969: @c Here is a sample session with the multi-function calculator:
 2970: 
 2971: さらに、電卓にメモリを追加し、名前付き変数を作り、そこに値を記憶し、
 2972: 後で使えるようにしましょう。
 2973: 以下に多機能電卓を使う作業の例を示します。
 2974: 
 2975: @example
 2976: % mfcalc
 2977: pi = 3.141592653589
 2978: 3.1415926536
 2979: sin(pi)
 2980: 0.0000000000
 2981: alpha = beta1 = 2.3
 2982: 2.3000000000
 2983: alpha
 2984: 2.3000000000
 2985: ln(alpha)
 2986: 0.8329091229
 2987: exp(ln(beta1))
 2988: 2.3000000000
 2989: %
 2990: @end example
 2991: 
 2992: @c Note that multiple assignment and nested function calls are permitted.
 2993: 
 2994: 複数の代入@footnote{【訳注】例の@samp{alpha = beta1 = 2.3}}と
 2995: 関数の入れ子@footnote{【訳注】例の@samp{exp(ln(beta1))}}が
 2996: 許されることに注意してください。
 2997: 
 2998: @menu
 2999: * Decl: Mfcalc Decl.      Bison declarations for multi-function calculator.
 3000: * Rules: Mfcalc Rules.    Grammar rules for the calculator.
 3001: * Symtab: Mfcalc Symtab.  Symbol table management subroutines.
 3002: @end menu
 3003: 
 3004: 
 3005: @c =====================================================================
 3006: @node Mfcalc Decl, Mfcalc Rules,  , Multi-function Calc
 3007: @c @subsection Declarations for @code{mfcalc}
 3008: @subsection @code{mfcalc}のための定義
 3009: 
 3010: @c Here are the C and Bison declarations for the multi-function calculator.
 3011: 
 3012: 以下には、多機能電卓のための、CとBisonの宣言があります。
 3013: 
 3014: @smallexample
 3015: %@{
 3016: @c #include <math.h>  /* For math functions, cos(), sin(), etc. */
 3017: #include <math.h>  /* cos(), sin()などの数学関数のため */
 3018: @c #include "calc.h"  /* Contains definition of `symrec'        */
 3019: #include "calc.h"  /* `symrec'の定義を含む             */
 3020: %@}
 3021: %union @{
 3022: @c double     val;  /* For returning numbers.                   */
 3023: double     val;    /* 数値を返すため                   */
 3024: @c symrec  *tptr;   /* For returning symbol-table pointers      */
 3025: symrec  *tptr;     /* 記号表へのポインタを返すため     */
 3026: @}
 3027: 
 3028: @c %token <val>  NUM        /* Simple double precision number   */
 3029: %token <val>  NUM        /* 単純な倍精度数値 */
 3030: @c %token <tptr> VAR FNCT   /* Variable and Function            */
 3031: %token <tptr> VAR FNCT   /* 変数と関数       */
 3032: %type  <val>  exp
 3033: 
 3034: %right '='
 3035: %left '-' '+'
 3036: %left '*' '/'
 3037: @c %left NEG     /* Negation--unary minus */
 3038: %left NEG     /* 否定 -- 単項の負 */
 3039: @c %right '^'    /* Exponentiation        */
 3040: %right '^'    /* べき乗           */
 3041: 
 3042: @c /* Grammar follows */
 3043: /* 文法が続く */
 3044: 
 3045: %%
 3046: @end smallexample
 3047: 
 3048: @c The above grammar introduces only two new features of the Bison language.
 3049: @c These features allow semantic values to have various data types
 3050: @c (@pxref{Multiple Types, ,More Than One Value Type}).
 3051: 
 3052: この文法の導入部分では、Bison言語の新しい2つの機能を使っています。
 3053: これらの機能によって、意味値がいろいろなデータ型を持てます
 3054: (@pxref{Multiple Types, ,More Than One Value Type})。
 3055: 
 3056: @c The @code{%union} declaration specifies the entire list of possible types;
 3057: @c this is instead of defining @code{YYSTYPE}.  The allowable types are now
 3058: @c double-floats (for @code{exp} and @code{NUM}) and pointers to entries in
 3059: @c the symbol table.  @xref{Union Decl, ,The Collection of Value Types}.
 3060: 
 3061: @code{%union}宣言は、@code{YYSTYPE}の定義の代わりで、
 3062: 可能な型の一覧を指定します。
 3063: ここで許される型は、(@code{exp}と@code{NUM}のための)倍精度浮動小数点型と、
 3064: 記号表の項目へのポインタです。
 3065: @xref{Union Decl, ,The Collection of Value Types}。
 3066: 
 3067: @c Since values can now have various types, it is necessary to associate a
 3068: @c type with each grammar symbol whose semantic value is used.  These symbols
 3069: @c are @code{NUM}, @code{VAR}, @code{FNCT}, and @code{exp}.  Their
 3070: @c declarations are augmented with information about their data type (placed
 3071: @c between angle brackets).
 3072: 
 3073: 値がいろいろな型を持つことができるので、
 3074: 意味値を使うそれぞれの文法記号に対して、
 3075: 型を関連づける必要があります。
 3076: これらの記号は@code{NUM}、@code{VAR}、@code{FNCT}、@code{exp}です。
 3077: それらの宣言は、不等号で囲まれた(@samp{<...>})データ型に関する
 3078: 情報を付加されています。
 3079: 
 3080: @c The Bison construct @code{%type} is used for declaring nonterminal symbols,
 3081: @c just as @code{%token} is used for declaring token types.  We have not used
 3082: @c @code{%type} before because nonterminal symbols are normally declared
 3083: @c implicitly by the rules that define them.  But @code{exp} must be declared
 3084: @c explicitly so we can specify its value type.
 3085: @c @xref{Type Decl, ,Nonterminal Symbols}.
 3086: 
 3087: Bisonは、ちょうど@code{%token}がトークン型の宣言に使われるのと同じように、
 3088: @code{%type}が非終端記号の宣言に使われるようにします。
 3089: 非終端記号は通常それらを定義する規則によって暗黙に宣言されるので、
 3090: @code{%type}をその規則よりも先に使ってはいけません。
 3091: しかし、@code{exp}は、その値の型を指定するので、
 3092: 明示的に宣言する必要があります。
 3093: @xref{Type Decl, ,Nonterminal Symbols}。
 3094: 
 3095: 
 3096: @c =====================================================================
 3097: @node Mfcalc Rules, Mfcalc Symtab, Mfcalc Decl, Multi-function Calc
 3098: @c @subsection Grammar Rules for @code{mfcalc}
 3099: @subsection @code{mfcalc}のための文法規則
 3100: 
 3101: @c Here are the grammar rules for the multi-function calculator.
 3102: @c Most of them are copied directly from @code{calc}; three rules,
 3103: @c those which mention @code{VAR} or @code{FNCT}, are new.
 3104: 
 3105: 多機能電卓のための文法規則を示します。
 3106: 大部分は、@code{calc}の文法規則からの複写です。
 3107: @code{VAR}、@code{FUNCT}に関連する3つの規則が新しいものです。
 3108: 
 3109: @smallexample
 3110: @c input:   /* empty */
 3111: input:   /* 空 */
 3112:         | input line
 3113: ;
 3114: 
 3115: line:
 3116:           '\n'
 3117:         | exp '\n'   @{ printf ("\t%.10g\n", $1); @}
 3118:         | error '\n' @{ yyerrok;                  @}
 3119: ;
 3120: 
 3121: exp:      NUM                @{ $$ = $1;                         @}
 3122:         | VAR                @{ $$ = $1->value.var;              @}
 3123:         | VAR '=' exp        @{ $$ = $3; $1->value.var = $3;     @}
 3124:         | FNCT '(' exp ')'   @{ $$ = (*($1->value.fnctptr))($3); @}
 3125:         | exp '+' exp        @{ $$ = $1 + $3;                    @}
 3126:         | exp '-' exp        @{ $$ = $1 - $3;                    @}
 3127:         | exp '*' exp        @{ $$ = $1 * $3;                    @}
 3128:         | exp '/' exp        @{ $$ = $1 / $3;                    @}
 3129:         | '-' exp  %prec NEG @{ $$ = -$2;                        @}
 3130:         | exp '^' exp        @{ $$ = pow ($1, $3);               @}
 3131:         | '(' exp ')'        @{ $$ = $2;                         @}
 3132: ;
 3133: @c /* End of grammar */
 3134: /* 文法の終わり */
 3135: %%
 3136: @end smallexample
 3137: 
 3138: 
 3139: @c =====================================================================
 3140: @node Mfcalc Symtab,  , Mfcalc Rules, Multi-function Calc
 3141: @c @subsection The @code{mfcalc} Symbol Table
 3142: @subsection @code{mfcalc}の記号表
 3143: @cindex symbol table example
 3144: @cindex 記号表の例
 3145: 
 3146: @c The multi-function calculator requires a symbol table to keep track of the
 3147: @c names and meanings of variables and functions.  This doesn't affect the
 3148: @c grammar rules (except for the actions) or the Bison declarations, but it
 3149: @c requires some additional C functions for support.
 3150: 
 3151: 変数と関数の名前と意味を保持するために、
 3152: 多機能電卓は記号表を必要とします。
 3153: これは、アクションを除く文法規則とBison宣言には影響しませんが、
 3154: 追加のCの関数がいくつか必要です。
 3155: 
 3156: @c The symbol table itself consists of a linked list of records.  Its
 3157: @c definition, which is kept in the header @file{calc.h}, is as follows.  It
 3158: @c provides for either functions or variables to be placed in the table.
 3159: 
 3160: 記号表は、レコードのリンクリストからなります。
 3161: その定義は、後述の、ヘッダファイル@file{calc.h}にあります。
 3162: 関数と変数の両方を表に置くことができます。
 3163: 
 3164: @smallexample
 3165: @group
 3166: @c /* Data type for links in the chain of symbols.      */
 3167: /* 記号表のリンクを表すデータ型                 */
 3168: struct symrec
 3169: @{
 3170: @c  char *name;  /* name of symbol                     */
 3171:   char *name;  /* 記号の名前                    */
 3172: @c  int type;    /* type of symbol: either VAR or FNCT */
 3173:   int type;    /* 記号の種類:VARまたはFNCT     */
 3174:   union @{
 3175: @c    double var;           /* value of a VAR          */
 3176:     double var;           /* VARの値            */
 3177: @c    double (*fnctptr)();  /* value of a FNCT         */
 3178:     double (*fnctptr)();  /* FNCTの値           */
 3179:   @} value;
 3180: @c  struct symrec *next;    /* link field              */
 3181:   struct symrec *next;    /* 次の項目へのリンク */
 3182: @};
 3183: @end group
 3184: 
 3185: @group
 3186: typedef struct symrec symrec;
 3187: 
 3188: @c /* The symbol table: a chain of `struct symrec'.     */
 3189: /* `struct symrec'のリンクである記号表          */
 3190: extern symrec *sym_table;
 3191: 
 3192: symrec *putsym ();
 3193: symrec *getsym ();
 3194: @end group
 3195: @end smallexample
 3196: 
 3197: @c The new version of @code{main} includes a call to @code{init_table}, a
 3198: @c function that initializes the symbol table.  Here it is, and
 3199: @c @code{init_table} as well:
 3200: 
 3201: 新しい@code{main}関数は、記号表を初期化する関数である
 3202: @code{init_table}を呼びます。
 3203: @code{main}と@code{init_table}を以下に示します。
 3204: 
 3205: @smallexample
 3206: @group
 3207: #include <stdio.h>
 3208: 
 3209: main ()
 3210: @{
 3211:   init_table ();
 3212:   yyparse ();
 3213: @}
 3214: @end group
 3215: 
 3216: @group
 3217: @c yyerror (s)  /* Called by yyparse on error */
 3218: yyerror (s)  /* エラーがあるとyyparseから呼び出される */
 3219:      char *s;
 3220: @{
 3221:   printf ("%s\n", s);
 3222: @}
 3223: 
 3224: struct init
 3225: @{
 3226:   char *fname;
 3227:   double (*fnct)();
 3228: @};
 3229: @end group
 3230: 
 3231: @group
 3232: struct init arith_fncts[]
 3233:   = @{
 3234:       "sin", sin,
 3235:       "cos", cos,
 3236:       "atan", atan,
 3237:       "ln", log,
 3238:       "exp", exp,
 3239:       "sqrt", sqrt,
 3240:       0, 0
 3241:     @};
 3242: 
 3243: @c /* The symbol table: a chain of `struct symrec'.  */
 3244: /* 記号表:`struct symrec'のリスト       */
 3245: symrec *sym_table = (symrec *)0;
 3246: @end group
 3247: 
 3248: @group
 3249: @c init_table ()  /* puts arithmetic functions in table. */
 3250: init_table ()  /* 数学関数を表に登録する */
 3251: @{
 3252:   int i;
 3253:   symrec *ptr;
 3254:   for (i = 0; arith_fncts[i].fname != 0; i++)
 3255:     @{
 3256:       ptr = putsym (arith_fncts[i].fname, FNCT);
 3257:       ptr->value.fnctptr = arith_fncts[i].fnct;
 3258:     @}
 3259: @}
 3260: @end group
 3261: @end smallexample
 3262: 
 3263: @c By simply editing the initialization list and adding the necessary include
 3264: @c files, you can add additional functions to the calculator.
 3265: 
 3266: 単純に初期化リストを編集して、必要なインクルードファイルを追加するだけで、
 3267: 電卓に関数を追加できます。
 3268: 
 3269: @c Two important functions allow look-up and installation of symbols in the
 3270: @c symbol table.  The function @code{putsym} is passed a name and the type
 3271: @c (@code{VAR} or @code{FNCT}) of the object to be installed.  The object is
 3272: @c linked to the front of the list, and a pointer to the object is returned.
 3273: @c The function @code{getsym} is passed the name of the symbol to look up.  If
 3274: @c found, a pointer to that symbol is returned; otherwise zero is returned.
 3275: 
 3276: 記号表に記号を登録して検索するために、2個の重要な関数があります。
 3277: 関数@code{putsym}は、登録すべきオブジェクトの
 3278: 名前と型(@code{VAR}や@code{FNCT})を渡されます。
 3279: オブジェクトはリストの先頭にリンクされ、
 3280: オブジェクトへのポインタが返されます。
 3281: 関数@code{getsym}は、検索すべき記号の名前を渡されます。
 3282: もし見つかれば記号へのポインタが返され、
 3283: 見つからなければ0が返されます。
 3284: 
 3285: @smallexample
 3286: symrec *
 3287: putsym (sym_name,sym_type)
 3288:      char *sym_name;
 3289:      int sym_type;
 3290: @{
 3291:   symrec *ptr;
 3292:   ptr = (symrec *) malloc (sizeof (symrec));
 3293:   ptr->name = (char *) malloc (strlen (sym_name) + 1);
 3294:   strcpy (ptr->name,sym_name);
 3295:   ptr->type = sym_type;
 3296: @c  ptr->value.var = 0; /* set value to 0 even if fctn.  */
 3297:   ptr->value.var = 0; /* 関数の場合にも値を0にする */
 3298:   ptr->next = (struct symrec *)sym_table;
 3299:   sym_table = ptr;
 3300:   return ptr;
 3301: @}
 3302: 
 3303: symrec *
 3304: getsym (sym_name)
 3305:      char *sym_name;
 3306: @{
 3307:   symrec *ptr;
 3308:   for (ptr = sym_table; ptr != (symrec *) 0;
 3309:        ptr = (symrec *)ptr->next)
 3310:     if (strcmp (ptr->name,sym_name) == 0)
 3311:       return ptr;
 3312:   return 0;
 3313: @}
 3314: @end smallexample
 3315: 
 3316: @c The function @code{yylex} must now recognize variables, numeric values, and
 3317: @c the single-character arithmetic operators.  Strings of alphanumeric
 3318: @c characters with a leading nondigit are recognized as either variables or
 3319: @c functions depending on what the symbol table says about them.
 3320: 
 3321: 今度の関数@code{yylex}は、変数、数値、1文字の算術演算子を
 3322: 認識する必要があります。
 3323: 英字で始まり英数字からなる文字列は、記号表にどう書かれているかに応じて、
 3324: 変数と関数のどちらとも認識されます。
 3325: 
 3326: @c The string is passed to @code{getsym} for look up in the symbol table.  If
 3327: @c the name appears in the table, a pointer to its location and its type
 3328: @c (@code{VAR} or @code{FNCT}) is returned to @code{yyparse}.  If it is not
 3329: @c already in the table, then it is installed as a @code{VAR} using
 3330: @c @code{putsym}.  Again, a pointer and its type (which must be @code{VAR}) is
 3331: @c returned to @code{yyparse}.@refill
 3332: 
 3333: 文字列は、記号表を検索するために@code{getsym}に渡されます。
 3334: もし名前が表にあれば、その場所へのポインタと
 3335: 名前の型(@code{VAR}または@code{FNCT})が、
 3336: @code{yyparse}に返されます。
 3337: 名前がまだ表になければ、@code{putsym}を使って、
 3338: @code{VAR}として登録されます。
 3339: そして、ポインタと型(この場合には必ず@code{VAR})が
 3340: @code{yyparse}に返されます。
 3341: 
 3342: @c No change is needed in the handling of numeric values and arithmetic
 3343: @c operators in @code{yylex}.
 3344: 
 3345: @code{yylex}の中で、数値と算術演算子の扱いに関する部分は、
 3346: 変更する必要がありません。
 3347: 
 3348: @smallexample
 3349: @group
 3350: #include <ctype.h>
 3351: yylex ()
 3352: @{
 3353:   int c;
 3354: 
 3355: @c  /* Ignore whitespace, get first nonwhite character.  */
 3356:   /* 空白を読み飛ばし、空白以外を得る         */
 3357:   while ((c = getchar ()) == ' ' || c == '\t');
 3358: 
 3359:   if (c == EOF)
 3360:     return 0;
 3361: @end group
 3362: 
 3363: @group
 3364: @c  /* Char starts a number => parse the number.         */
 3365:   /* 数値を読む   */
 3366:   if (c == '.' || isdigit (c))
 3367:     @{
 3368:       ungetc (c, stdin);
 3369:       scanf ("%lf", &yylval.val);
 3370:       return NUM;
 3371:     @}
 3372: @end group
 3373: 
 3374: @group
 3375: @c  /* Char starts an identifier => read the name.       */
 3376:   /* 識別子を読む */
 3377:   if (isalpha (c))
 3378:     @{
 3379:       symrec *s;
 3380:       static char *symbuf = 0;
 3381:       static int length = 0;
 3382:       int i;
 3383: @end group
 3384: 
 3385: @group
 3386: @c      /* Initially make the buffer long enough
 3387: @c         for a 40-character symbol name.  */
 3388:       /* バッファの長さの初期値は40文字       */
 3389:       if (length == 0)
 3390:         length = 40, symbuf = (char *)malloc (length + 1);
 3391: 
 3392:       i = 0;
 3393:       do
 3394: @end group
 3395: @group
 3396:         @{
 3397: @c          /* If buffer is full, make it bigger.        */
 3398:           /* あふれたのでバッファを大きくする */
 3399:           if (i == length)
 3400:             @{
 3401:               length *= 2;
 3402:               symbuf = (char *)realloc (symbuf, length + 1);
 3403:             @}
 3404: @c          /* Add this character to the buffer.         */
 3405:           /* 文字をバッファに変える           */
 3406:           symbuf[i++] = c;
 3407: @c          /* Get another character.                    */
 3408:           /* 次の文字を読む                   */
 3409:           c = getchar ();
 3410:         @}
 3411: @end group
 3412: @group
 3413:       while (c != EOF && isalnum (c));
 3414: 
 3415:       ungetc (c, stdin);
 3416:       symbuf[i] = '\0';
 3417: @end group
 3418: 
 3419: @group
 3420:       s = getsym (symbuf);
 3421:       if (s == 0)
 3422:         s = putsym (symbuf, VAR);
 3423:       yylval.tptr = s;
 3424:       return s->type;
 3425:     @}
 3426: 
 3427: @c  /* Any other character is a token by itself.        */
 3428:   /* その他の文字は文字リテラルトークン       */
 3429:   return c;
 3430: @}
 3431: @end group
 3432: @end smallexample
 3433: 
 3434: @c This program is both powerful and flexible. You may easily add new
 3435: @c functions, and it is a simple job to modify this code to install predefined
 3436: @c variables such as @code{pi} or @code{e} as well.
 3437: 
 3438: このプログラムは、強力かつ柔軟です。
 3439: 新しい関数の追加は簡単です。
 3440: @code{pi}や@code{e}のようにあらかじめ定義された変数を追加するために
 3441: プログラムを変更することは、簡単な仕事でしょう。
 3442: 
 3443: 
 3444: @c =====================================================================
 3445: @node Exercises,  , Multi-function Calc, Examples
 3446: @c @section Exercises
 3447: @section 練習問題
 3448: @cindex exercises
 3449: @cindex 練習問題
 3450: 
 3451: @enumerate
 3452: @item
 3453: @c Add some new functions from @file{math.h} to the initialization list.
 3454: @c
 3455: @file{math.h}にある関数のいくつかを、初期化リストに追加しなさい。
 3456: 
 3457: @item
 3458: @c Add another array that contains constants and their values.  Then
 3459: @c modify @code{init_table} to add these constants to the symbol table.
 3460: @c It will be easiest to give the constants type @code{VAR}.
 3461: @c
 3462: 定数の名前と値を記憶する別の配列を追加しなさい。
 3463: そして、@code{init_table}を変更し、定数を記号表に追加しなさい。
 3464: 定数に型@code{VAR}を与えれば簡単でしょう。
 3465: 
 3466: @item
 3467: @c Make the program report an error if the user refers to an
 3468: @c uninitialized variable in any way except to store a value in it.
 3469: @c
 3470: 初期化されていない変数について、値を書き込むのではなく、
 3471: 値を使おうとするとエラーを報告するように、プログラムを改良しなさい。
 3472: @end enumerate
 3473: 
 3474: 
 3475: @c =====================================================================
 3476: @node Grammar File, Interface, Examples, Top
 3477: @c @chapter Bison Grammar Files
 3478: @chapter Bison文法ファイル
 3479: 
 3480: @c Bison takes as input a context-free grammar specification and produces a
 3481: @c C-language function that recognizes correct instances of the grammar.
 3482: 
 3483: Bisonは、文脈自由文法の仕様を入力として受け取り、
 3484: その文法の正しいインスタンスを認識する、
 3485: C言語の関数を生成します。
 3486: 
 3487: @c The Bison grammar input file conventionally has a name ending in @samp{.y}.
 3488: 
 3489: Bison文法ファイルの名前は、通常@samp{.y}で終わります。
 3490: 
 3491: @menu
 3492: * Grammar Outline::   Overall layout of the grammar file.
 3493: * Symbols::           Terminal and nonterminal symbols.
 3494: * Rules::             How to write grammar rules.
 3495: * Recursion::         Writing recursive rules.
 3496: * Semantics::         Semantic values and actions.
 3497: * Declarations::      All kinds of Bison declarations are described here.
 3498: * Multiple Parsers::  Putting more than one Bison parser in one program.
 3499: @end menu
 3500: 
 3501: 
 3502: @c =====================================================================
 3503: @node Grammar Outline, Symbols,  , Grammar File
 3504: @c @section Outline of a Bison Grammar
 3505: @section Bison文法の概要
 3506: 
 3507: @c A Bison grammar file has four main sections, shown here with the
 3508: @c appropriate delimiters:
 3509: 
 3510: Bison文法ファイルは4つの主要な部分からなります。
 3511: それらを、適切な区切り文字とともに示します。
 3512: 
 3513: @example
 3514: %@{
 3515: @c @var{C declarations}
 3516: @var{C宣言部(C declarations)}
 3517: %@}
 3518: 
 3519: @c @var{Bison declarations}
 3520: @var{Bison宣言部(Bison declarations)}
 3521: 
 3522: %%
 3523: @c @var{Grammar rules}
 3524: @var{文法規則部(Grammar rules)}
 3525: %%
 3526: 
 3527: @c @var{Additional C code}
 3528: @var{追加のCプログラム部(Additional C code)}
 3529: @end example
 3530: 
 3531: @c Comments enclosed in @samp{/* @dots{} */} may appear in any of the sections.
 3532: 
 3533: @samp{/* @dots{} */}で囲まれたコメントは、どの部分にも書けます。
 3534: 
 3535: @menu
 3536: * C Declarations::    Syntax and usage of the C declarations section.
 3537: * Bison Declarations::  Syntax and usage of the Bison declarations section.
 3538: * Grammar Rules::     Syntax and usage of the grammar rules section.
 3539: * C Code::            Syntax and usage of the additional C code section.
 3540: @end menu
 3541: 
 3542: 
 3543: @c =====================================================================
 3544: @node C Declarations, Bison Declarations,  , Grammar Outline
 3545: @c @subsection The C Declarations Section
 3546: @subsection C宣言部
 3547: @cindex C declarations section
 3548: @cindex declarations, C
 3549: @cindex C宣言部
 3550: @cindex 宣言, C
 3551: 
 3552: @c The @var{C declarations} section contains macro definitions and
 3553: @c declarations of functions and variables that are used in the actions in the
 3554: @c grammar rules.  These are copied to the beginning of the parser file so
 3555: @c that they precede the definition of @code{yyparse}.  You can use
 3556: @c @samp{#include} to get the declarations from a header file.  If you don't
 3557: @c need any C declarations, you may omit the @samp{%@{} and @samp{%@}}
 3558: @c delimiters that bracket this section.
 3559: 
 3560: @dfn{C宣言部(C declarations)}には、マクロ定義と、文法定義のアクションで
 3561: 使うための関数と変数の宣言があります。
 3562: これらは、@code{yyparse}の定義に優先するように、構文解析器ファイルの最初に
 3563: 複写されます。
 3564: ヘッダファイルから宣言を得るには@samp{#include}を使います。
 3565: C宣言がまったく必要ない場合は、この部分を囲む
 3566: @samp{%@{}と@samp{%@}}を省略できます。
 3567: 
 3568: 
 3569: @c =====================================================================
 3570: @node Bison Declarations, Grammar Rules, C Declarations, Grammar Outline
 3571: @c @subsection The Bison Declarations Section
 3572: @subsection Bison宣言部
 3573: @cindex Bison declarations (introduction)
 3574: @cindex declarations, Bison (introduction)
 3575: @cindex Bison宣言(導入)
 3576: @cindex 宣言, Bison(導入)
 3577: 
 3578: @c The @var{Bison declarations} section contains declarations that define
 3579: @c terminal and nonterminal symbols, specify precedence, and so on.
 3580: @c In some simple grammars you may not need any declarations.
 3581: @c @xref{Declarations, ,Bison Declarations}.
 3582: 
 3583: @dfn{Bison宣言部(Bison declarations)}は、終端記号と非終端記号の宣言、
 3584: 演算子の優先順位の指定などを含みます。
 3585: 単純な例では、宣言を省略できます。
 3586: @xref{Declarations, ,Bison Declarations}。
 3587: 
 3588: 
 3589: @c =====================================================================
 3590: @node Grammar Rules, C Code, Bison Declarations, Grammar Outline
 3591: @c @subsection The Grammar Rules Section
 3592: @subsection 文法規則部
 3593: @cindex grammar rules section
 3594: @cindex rules section for grammar
 3595: @cindex 文法規則部
 3596: @cindex 規則部,文法に対する
 3597: 
 3598: @c The @dfn{grammar rules} section contains one or more Bison grammar
 3599: @c rules, and nothing else.  @xref{Rules, ,Syntax of Grammar Rules}.
 3600: 
 3601: @dfn{文法規則部(grammar rules)}は、1つ以上のBison文法規則を含み、
 3602: それ以外は含みません。
 3603: @xref{Rules, ,Syntax of Grammar Rules}。
 3604: 
 3605: @c There must always be at least one grammar rule, and the first
 3606: @c @samp{%%} (which precedes the grammar rules) may never be omitted even
 3607: @c if it is the first thing in the file.
 3608: 
 3609: 少なくとも1つの文法規則が存在する必要があります。
 3610: また、文法規則より先に@samp{%%}が必要で、
 3611: もしそれ以前に何も記述されていなくても、省略できません。
 3612: 
 3613: 
 3614: @c =====================================================================
 3615: @node C Code,  , Grammar Rules, Grammar Outline
 3616: @c @subsection The Additional C Code Section
 3617: @subsection 追加のCプログラム部
 3618: @cindex additional C code section
 3619: @cindex C code, section for additional
 3620: @cindex 追加のCプログラム部
 3621: @cindex Cプログラム, 追加の
 3622: 
 3623: @c The @var{additional C code} section is copied verbatim to the end of
 3624: @c the parser file, just as the @var{C declarations} section is copied to
 3625: @c the beginning.  This is the most convenient place to put anything
 3626: @c that you want to have in the parser file but which need not come before
 3627: @c the definition of @code{yyparse}.  For example, the definitions of
 3628: @c @code{yylex} and @code{yyerror} often go here.
 3629: @c @xref{Interface, ,Parser C-Language Interface}.
 3630: 
 3631: @dfn{追加のCプログラム部(additional C code)}は、@dfn{C宣言部}が構文解析器ファイルの先頭に複写
 3632: されるのと同じように、構文解析器ファイルの末尾にそのまま複写されます。
 3633: 構文解析器ファイル中に置く必要があって、
 3634: @code{yyparse}の定義よりも前に置く必要のないものを、ここに置くと便利です。
 3635: たとえば、@code{yylex}と@code{yyerror}の定義は、
 3636: よくここに置かれます。
 3637: @xref{Interface, ,Parser C-Language Interface}。
 3638: 
 3639: @c If the last section is empty, you may omit the @samp{%%} that separates it
 3640: @c from the grammar rules.
 3641: 
 3642: もし直前の部が空ならば、文法規則と区別するための
 3643: @samp{%%}を省略できます。
 3644: 
 3645: @c The Bison parser itself contains many static variables whose names start
 3646: @c with @samp{yy} and many macros whose names start with @samp{YY}.  It is a
 3647: @c good idea to avoid using any such names (except those documented in this
 3648: @c manual) in the additional C code section of the grammar file.
 3649: 
 3650: Bison構文解析器は、名前が@samp{yy}で始まる多くの静的変数と、
 3651: 名前が@samp{YY}で始まる多くのマクロを含んでいます。
 3652: 本書で解説しているものを意図的に使う場合を除いて、
 3653: そのような名前を文法ファイルの追加のCプログラム部で使うのは避けるべきです。
 3654: 
 3655: 
 3656: @c =====================================================================
 3657: @node Symbols, Rules, Grammar Outline, Grammar File
 3658: @c @section Symbols, Terminal and Nonterminal
 3659: @section 記号、終端と非終端
 3660: @cindex nonterminal symbol
 3661: @cindex terminal symbol
 3662: @cindex token type
 3663: @cindex symbol
 3664: @cindex 非終端記号
 3665: @cindex 終端記号
 3666: @cindex トークン型
 3667: @cindex 記号
 3668: 
 3669: @c @dfn{Symbols} in Bison grammars represent the grammatical classifications
 3670: @c of the language.
 3671: 
 3672: Bison文法の@dfn{記号(symbols)}は、
 3673: 言語の文法的分類を表現します。
 3674: 
 3675: @c A @dfn{terminal symbol} (also known as a @dfn{token type}) represents a
 3676: @c class of syntactically equivalent tokens.  You use the symbol in grammar
 3677: @c rules to mean that a token in that class is allowed.  The symbol is
 3678: @c represented in the Bison parser by a numeric code, and the @code{yylex}
 3679: @c function returns a token type code to indicate what kind of token has been
 3680: @c read.  You don't need to know what the code value is; you can use the
 3681: @c symbol to stand for it.
 3682: 
 3683: @dfn{終端記号(terminal symbol)}
 3684: (@dfn{トークン型(tokens types)}ともいいます)は、
 3685: 構文的に等価なトークンのクラスを表します。
 3686: そのクラスのトークンが許されることを表すために、
 3687: 文法規則の中で記号を使えます。
 3688: その記号は、Bison構文解析器の中で番号で表現され、
 3689: @code{yylex}関数は、どのような種類のトークンが読み込まれたかを示すために、
 3690: トークン番号を返します。
 3691: これを表す記号を知っていればよく、その番号を知っている必要はありません。
 3692: 
 3693: @c A @dfn{nonterminal symbol} stands for a class of syntactically equivalent
 3694: @c groupings.  The symbol name is used in writing grammar rules.
 3695: @c By convention, it should be all lower case.
 3696: 
 3697: @dfn{非終端記号(nonterminal symbol)}は、
 3698: 構文的に等価なグループを表現します。
 3699: 記号名は文法規則の記述に使われます。
 3700: 通常、非終端記号名を小文字で書きます。
 3701: 
 3702: @c Symbol names can contain letters, digits (not at the beginning),
 3703: @c underscores and periods.  Periods make sense only in nonterminals.
 3704: 
 3705: 記号名は、英字、先頭以外での数字、下線記号(@samp{_})とピリオドからなります。
 3706: ピリオド記号(@samp{.})は、非終端記号の名前には使えますが、
 3707: 終端記号の名前には使えません。
 3708: 
 3709: @c There are three ways of writing terminal symbols in the grammar:
 3710: 
 3711: 文法中で終端記号を記述するには3種類の方法があります。
 3712: 
 3713: @itemize @bullet
 3714: @item
 3715: @c A @dfn{named token type} is written with an identifier, like an
 3716: @c identifier in C.  By convention, it should be all upper case.  Each
 3717: @c such name must be defined with a Bison declaration such as
 3718: @c @code{%token}.  @xref{Token Decl, ,Token Type Names}.
 3719: @c 
 3720: @dfn{名前付きトークン型(named token type)}を、
 3721: C言語における識別子と同様な、識別子とともに書きます。
 3722: 通常、大文字で書きます。
 3723: これらは@code{%token}のようなBison宣言とともに定義する必要があります。
 3724: @xref{Token Decl, ,Token Type Names}。
 3725: 
 3726: @item
 3727: @cindex character token
 3728: @cindex literal token
 3729: @cindex single-character literal
 3730: @cindex 文字トークン
 3731: @cindex リテラルトークン
 3732: @cindex 1文字リテラル
 3733: @c A @dfn{character token type} (or @dfn{literal character token}) is
 3734: @c written in the grammar using the same syntax used in C for character
 3735: @c constants; for example, @code{'+'} is a character token type.  A
 3736: @c character token type doesn't need to be declared unless you need to
 3737: @c specify its semantic value data type (@pxref{Value Type, ,Data Types of
 3738: @c Semantic Values}), associativity, or precedence (@pxref{Precedence,
 3739: @c ,Operator Precedence}).
 3740: @c 
 3741: @dfn{文字トークン型(character token type)}、
 3742: すなわち@dfn{リテラル文字トークン(literal character token)}は、
 3743: C言語の文字定数と同じ構文で書かれ、
 3744: たとえば@code{'+'}は文字トークン型です。
 3745: 意味値データ型(@pxref{Value Type, ,Data Types of Semantic Values})、
 3746: 結合性、優先順位(@pxref{Precedence, ,Operator Precedence})を
 3747: 指定する必要がなければ、
 3748: 文字トークン型を宣言する必要はありません。
 3749: 
 3750: @c By convention, a character token type is used only to represent a
 3751: @c token that consists of that particular character.  Thus, the token
 3752: @c type @code{'+'} is used to represent the character @samp{+} as a
 3753: @c token.  Nothing enforces this convention, but if you depart from it,
 3754: @c your program will confuse other readers.
 3755: 
 3756: 通常、文字トークン型は、特別な文字@footnote{【訳注】英数字以外の文字。}から
 3757: なるトークンを表すためだけに使います。
 3758: たとえば、トークン型@code{'+'}を、
 3759: トークンとしての@samp{+}文字を表すために使います。
 3760: このようにする義務はありませんが、そうしないと、
 3761: あなたが書いたプログラムを読む人が混乱するでしょう。
 3762: 
 3763: @c All the usual escape sequences used in character literals in C can be
 3764: @c used in Bison as well, but you must not use the null character as a
 3765: @c character literal because its ASCII code, zero, is the code @code{yylex}
 3766: @c returns for end-of-input (@pxref{Calling Convention, ,Calling Convention
 3767: @c for @code{yylex}}).
 3768: 
 3769: C言語の文字リテラルで使われる通常のエスケープシーケンス
 3770: @footnote{【訳注】@samp{\}に続く表現。}を、Bisonでも使えます。
 3771: しかし、@code{'\0'}だけはASCII符号の0を表し、
 3772: @code{yylex}がファイルの終わりを示す符号なので、
 3773: 文字リテラルとしては使えません
 3774: (@pxref{Calling Convention, ,Calling Convention for @code{yylex}})。
 3775: 
 3776: @item
 3777: @cindex string token
 3778: @cindex literal string token
 3779: @cindex multi-character literal
 3780: @cindex 文字列トークン
 3781: @cindex リテラル文字列トークン
 3782: @cindex 複数文字リテラル
 3783: @c A @dfn{literal string token} is written like a C string constant; for
 3784: @c example, @code{"<="} is a literal string token.  A literal string token
 3785: @c doesn't need to be declared unless you need to specify its semantic
 3786: @c value data type (@pxref{Value Type}), associativity, precedence
 3787: @c (@pxref{Precedence}).
 3788: @c
 3789: @dfn{リテラル文字列トークン(literal string token)}は、
 3790: C言語における文字列定数と同様に書きます。
 3791: たとえば、@code{"<="}がリテラル文字列トークンです。
 3792: 意味値(@pxref{Value Type})、
 3793: 結合性、優先順位(@pxref{Precedence, ,Operator Precedence})を
 3794: 指定する必要がなければ、
 3795: リテラル文字列トークンを宣言する必要はありません。
 3796: 
 3797: @c You can associate the literal string token with a symbolic name as an
 3798: @c alias, using the @code{%token} declaration (@pxref{Token Decl, ,Token
 3799: @c Declarations}).  If you don't do that, the lexical analyzer has to
 3800: @c retrieve the token number for the literal string token from the
 3801: @c @code{yytname} table (@pxref{Calling Convention}).
 3802: 
 3803: @code{%token}宣言(@pxref{Token Decl, ,Token Declarations})を使って、
 3804: リテラル文字列トークンを、記号名の別名として関連づけられます。
 3805: そうしないと、字句解析器は、
 3806: @code{yytname}表(@pxref{Calling Convention})を使って、
 3807: リテラル文字列トークンからトークン番号を検索する必要があります。
 3808: 
 3809: @c @strong{WARNING}: literal string tokens do not work in Yacc.
 3810: 
 3811: @strong{【警告】}@code{yacc}ではリテラル文字列トークンを使えません。
 3812: 
 3813: @c By convention, a literal string token is used only to represent a token
 3814: @c that consists of that particular string.  Thus, you should use the token
 3815: @c type @code{"<="} to represent the string @samp{<=} as a token.  Bison
 3816: @c does not enforces this convention, but if you depart from it, people who
 3817: @c read your program will be confused.
 3818: 
 3819: 通常、特殊文字の列からなるトークンの表現にのみ、
 3820: リテラル文字列トークンを使います。
 3821: たとえば、トークンとしての@samp{<=}を表すために、
 3822: トークン型@code{"<="}を使うべきです。
 3823: そうする義務はありませんが、そうしないと、
 3824: あなたが書いたプログラムを読む人が混乱するでしょう。
 3825: 
 3826: @c All the escape sequences used in string literals in C can be used in
 3827: @c Bison as well.  A literal string token must contain two or more
 3828: @c characters; for a token containing just one character, use a character
 3829: @c token (see above).
 3830: @c
 3831: C言語で使えるエスケープシーケンスはすべてBisonでも使えます。
 3832: リテラル文字列トークンは、2文字以上からなります。
 3833: もし、トークンが1文字ならば、前述の1文字トークンを使ってください。
 3834: @end itemize
 3835: 
 3836: @c How you choose to write a terminal symbol has no effect on its
 3837: @c grammatical meaning.  That depends only on where it appears in rules and
 3838: @c on when the parser function returns that symbol.
 3839: 
 3840: 終端記号を書く方法は、終端記号の文法的意味に関係なく、
 3841: 規則の中に現れる位置と、
 3842: 構文解析器関数が記号を返す方法に関係します。
 3843: 
 3844: @c The value returned by @code{yylex} is always one of the terminal symbols
 3845: @c (or 0 for end-of-input).  Whichever way you write the token type in the
 3846: @c grammar rules, you write it the same way in the definition of @code{yylex}.
 3847: @c The numeric code for a character token type is simply the ASCII code for
 3848: @c the character, so @code{yylex} can use the identical character constant to
 3849: @c generate the requisite code.  Each named token type becomes a C macro in
 3850: @c the parser file, so @code{yylex} can use the name to stand for the code.
 3851: @c (This is why periods don't make sense in terminal symbols.)  
 3852: @c @xref{Calling Convention, ,Calling Convention for @code{yylex}}.
 3853: 
 3854: @code{yylex}が返す値は、終端記号のどれかを表し、
 3855: 入力の終わりでは0です。
 3856: 文法規則の中でどの方法でトークン型を書いても、
 3857: @code{yylex}を定義する書き方は同じです。
 3858: 1文字トークン型に対する符号は、その文字のASCII符号なので、
 3859: @code{yylex}は必要な符号を生成するために同一の文字定数を使えます。
 3860: 名前を付けられたトークン型はそれぞれ、
 3861: 構文解析器ファイルの中でCのマクロになるので、
 3862: @code{yylex}は符号に対するマクロ名を使えます。
 3863: これが、終端記号の名前にピリオド記号を使えない理由です。
 3864: @xref{Calling Convention, ,Calling Convention for @code{yylex}}。
 3865: 
 3866: @c If @code{yylex} is defined in a separate file, you need to arrange for the
 3867: @c token-type macro definitions to be available there.  Use the @samp{-d}
 3868: @c option when you run Bison, so that it will write these macro definitions
 3869: @c into a separate header file @file{@var{name}.tab.h} which you can include
 3870: @c in the other source files that need it.  @xref{Invocation, ,Invoking Bison}.
 3871: 
 3872: @code{yylex}が構文解析器と別のソースファイルの中に書かれる場合には、
 3873: そこでトークン型マクロ定義を使えるように準備する必要があります。
 3874: @samp{-d}オプションを付けてBisonを実行してください。
 3875: すると、マクロ定義が@file{@var{name}.tab.h}というファイルに書かれ、
 3876: 必要に応じて別のソースファイルからインクルードできます。
 3877: @xref{Invocation, ,Invoking Bison}。
 3878: 
 3879: @c The symbol @code{error} is a terminal symbol reserved for error recovery
 3880: @c (@pxref{Error Recovery}); you shouldn't use it for any other purpose.
 3881: @c In particular, @code{yylex} should never return this value.
 3882: 
 3883: 記号@code{error}は、エラー回復用に予約された終端記号(@pxref{Error Recovery})
 3884: で、他の目的に使うべきではありません。
 3885: 実際に、@code{yylex}がこの値を返すことは決してありません。
 3886: 
 3887: 
 3888: @c =====================================================================
 3889: @node Rules, Recursion, Symbols, Grammar File
 3890: @c @section Syntax of Grammar Rules
 3891: @section 文法規則の構文
 3892: @cindex rule syntax
 3893: @cindex grammar rule syntax
 3894: @cindex syntax of grammar rules
 3895: @cindex 規則の構文
 3896: @cindex 文法規則の構文
 3897: @cindex 構文, 文法規則
 3898: 
 3899: @c A Bison grammar rule has the following general form:
 3900: 
 3901: Bison文法規則は、一般的に次の書式です。
 3902: 
 3903: @example
 3904: @group
 3905: @var{result}: @var{components}@dots{}
 3906:         ;
 3907: @end group
 3908: @end example
 3909: 
 3910: @c @noindent
 3911: @c where @var{result} is the nonterminal symbol that this rule describes
 3912: @c and @var{components} are various terminal and nonterminal symbols that
 3913: @c are put together by this rule (@pxref{Symbols}).  
 3914: 
 3915: @c For example,
 3916: 
 3917: @var{result}は、この規則が記述する非終端記号で、
 3918: @var{components}は、この規則で一緒に置かれるさまざまな
 3919: 終端および非終端記号です。
 3920: 例を示します。
 3921: 
 3922: @example
 3923: @group
 3924: exp:      exp '+' exp
 3925:         ;
 3926: @end group
 3927: @end example
 3928: 
 3929: @c @noindent
 3930: @c says that two groupings of type @code{exp},
 3931: @c with a @samp{+} token in between,
 3932: @c can be combined into a larger grouping of type @code{exp}.
 3933: 
 3934: この例では、@samp{+}トークンを間にはさんで
 3935: 型@code{exp}の2つのグループ化が行われ、
 3936: 型@code{exp}のより大きなグループができます。
 3937: 
 3938: @c Whitespace in rules is significant only to separate symbols.  You can add
 3939: @c extra whitespace as you wish.
 3940: 
 3941: 規則の中の空白@footnote{【訳注】任意の数の空白文字、タブ符号、改行符号。}は、
 3942: 記号を分けるだけの意味を持ちます。
 3943: 必要に応じて、余分な空白を書いてもかまいません。
 3944: 
 3945: @c Scattered among the components can be @var{actions} that determine
 3946: @c the semantics of the rule.  An action looks like this:
 3947: 
 3948: @var{components}の周辺にあるものは、
 3949: 規則の意味を決定する@var{アクション(action)}になることができます。
 3950: アクションは、次のようになります。
 3951: 
 3952: @example
 3953: @{@var{C statements}@}
 3954: @end example
 3955: 
 3956: @c @noindent
 3957: @c Usually there is only one action and it follows the components.
 3958: @c @xref{Actions}.
 3959: 
 3960: 通常、1つだけのアクションと、それに続く@var{components}があります。
 3961: @xref{Actions}。
 3962: 
 3963: @findex |
 3964: @c Multiple rules for the same @var{result} can be written separately or can
 3965: @c be joined with the vertical-bar character @samp{|} as follows:
 3966: 
 3967: 同一の@var{result}に対する複数の規則は、
 3968: 別々に書くこともできますし、
 3969: 次の例のように縦線記号@samp{|}で区切ってまとめて書くことも可能です。
 3970: 
 3971: @ifinfo
 3972: @example
 3973: @var{result}:   @var{rule1-components}@dots{}
 3974:         | @var{rule2-components}@dots{}
 3975:         @dots{}
 3976:         ;
 3977: @end example
 3978: @end ifinfo
 3979: @iftex
 3980: @example
 3981: @group
 3982: @var{result}:    @var{rule1-components}@dots{}
 3983:         | @var{rule2-components}@dots{}
 3984:         @dots{}
 3985:         ;
 3986: @end group
 3987: @end example
 3988: @end iftex
 3989: 
 3990: @c @noindent
 3991: @c They are still considered distinct rules even when joined in this way.
 3992: 
 3993: まとめて書いても、それぞれの規則は別々のものとみなされます。
 3994: 
 3995: @c If @var{components} in a rule is empty, it means that @var{result} can
 3996: @c match the empty string.  For example, here is how to define a
 3997: @c comma-separated sequence of zero or more @code{exp} groupings:
 3998: 
 3999: もし、規則中の@var{components}が空ならば、
 4000: @var{result}が空の列にマッチできることを意味します。
 4001: 例として、カンマで区切られた0個以上の@code{exp}のグループを
 4002: 定義する方法を示します。
 4003: 
 4004: @example
 4005: @group
 4006: @c expseq:   /* empty */
 4007: expseq:   /* 空 */
 4008:         | expseq1
 4009:         ;
 4010: @end group
 4011: 
 4012: @group
 4013: expseq1:  exp
 4014:         | expseq1 ',' exp
 4015:         ;
 4016: @end group
 4017: @end example
 4018: 
 4019: @c @noindent
 4020: @c It is customary to write a comment @samp{/* empty */} in each rule
 4021: @c with no components.
 4022: 
 4023: 空の@var{component}を持つ規則には、通常
 4024: @samp{/* 空 */}という注釈を書きます。
 4025: 
 4026: 
 4027: @c =====================================================================
 4028: @node Recursion, Semantics, Rules, Grammar File
 4029: @c @section Recursive Rules
 4030: @section 再帰的規則
 4031: @cindex recursive rule
 4032: @cindex 再帰的規則
 4033: 
 4034: @c A rule is called @dfn{recursive} when its @var{result} nonterminal appears
 4035: @c also on its right hand side.  Nearly all Bison grammars need to use
 4036: @c recursion, because that is the only way to define a sequence of any number
 4037: @c of somethings.  Consider this recursive definition of a comma-separated
 4038: @c sequence of one or more expressions:
 4039: 
 4040: @var{result}である非終端記号が規則の右側にも現れる場合に、
 4041: その規則は@dfn{再帰的(recursive)}であるといいます。
 4042: Bison文法の大部分は再帰的規則を使います。
 4043: なぜならば、任意の数の並びを定義する唯一の方法が、
 4044: 再帰的規則だからです。
 4045: 1つ以上のカンマで区切られた式の並びの定義を考えてみましょう。
 4046: 
 4047: @example
 4048: @group
 4049: expseq1:  exp
 4050:         | expseq1 ',' exp
 4051:         ;
 4052: @end group
 4053: @end example
 4054: 
 4055: @cindex left recursion
 4056: @cindex right recursion
 4057: @cindex 左再帰
 4058: @cindex 右再帰
 4059: 
 4060: @c @noindent
 4061: @c Since the recursive use of @code{expseq1} is the leftmost symbol in the
 4062: @c right hand side, we call this @dfn{left recursion}.  By contrast, here
 4063: @c the same construct is defined using @dfn{right recursion}:
 4064: 
 4065: @code{expseq1}で使われている再帰は、規則の右側の中でもっとも左側にあるので、
 4066: このような再帰を@dfn{左再帰(left recursion)}と呼びます。
 4067: 逆に、同じ構造を@dfn{右再帰(right recursion)}を使って書いてみます。
 4068: 
 4069: @example
 4070: @group
 4071: expseq1:  exp
 4072:         | exp ',' expseq1
 4073:         ;
 4074: @end group
 4075: @end example
 4076: 
 4077: @c @noindent
 4078: @c Any kind of sequence can be defined using either left recursion or
 4079: @c right recursion, but you should always use left recursion, because it
 4080: @c can parse a sequence of any number of elements with bounded stack
 4081: @c space.  Right recursion uses up space on the Bison stack in proportion
 4082: @c to the number of elements in the sequence, because all the elements
 4083: @c must be shifted onto the stack before the rule can be applied even
 4084: @c once.  @xref{Algorithm, ,The Bison Parser Algorithm }, for
 4085: @c further explanation of this.
 4086: 
 4087: あらゆる並びを、左再帰を使っても、右再帰を使っても、定義できます。
 4088: しかし、限られたスタック容量で任意の数の並びを走査できるので、
 4089: つねに左再帰を使うべきです。
 4090: 右再帰では、規則が適用される前にすべての要素をスタックに積む必要があるので、
 4091: 要素の数に比例するスタック領域を消費します。
 4092: 詳細については、@xref{Algorithm, ,The Bison Parser Algorithm }。
 4093: 
 4094: @cindex mutual recursion
 4095: @cindex 相互再帰
 4096: 
 4097: @c @dfn{Indirect} or @dfn{mutual} recursion occurs when the result of the
 4098: @c rule does not appear directly on its right hand side, but does appear
 4099: @c in rules for other nonterminals which do appear on its right hand
 4100: @c side.  
 4101: 
 4102: 規則の結果が直接その右側には含まれず、
 4103: 右側にある非終端記号の中に含まれるとき、
 4104: @dfn{間接(indirect)}すなわち@dfn{相互(mutual)}再帰が起きます。
 4105: 
 4106: @c For example:
 4107: 
 4108: 例を示します。
 4109: 
 4110: @example
 4111: @group
 4112: expr:     primary
 4113:         | primary '+' primary
 4114:         ;
 4115: @end group
 4116: 
 4117: @group
 4118: primary:  constant
 4119:         | '(' expr ')'
 4120:         ;
 4121: @end group
 4122: @end example
 4123: 
 4124: @c @noindent
 4125: @c defines two mutually-recursive nonterminals, since each refers to the
 4126: @c other.
 4127: 
 4128: この例では、それぞれの規則が互いに参照しているので、
 4129: 2個の相互再帰が定義されています。
 4130: 
 4131: 
 4132: @c =====================================================================
 4133: @node Semantics, Declarations, Recursion, Grammar File
 4134: @c @section Defining Language Semantics
 4135: @section 言語の意味の定義
 4136: @cindex defining language semantics
 4137: @cindex language semantics, defining 
 4138: @cindex 言語の意味の定義
 4139: @cindex 定義, 言語の意味
 4140: 
 4141: @c The grammar rules for a language determine only the syntax.  The semantics
 4142: @c are determined by the semantic values associated with various tokens and
 4143: @c groupings, and by the actions taken when various groupings are recognized.
 4144: 
 4145: 言語に対する文法規則は、文法だけを決めます。
 4146: 意味は、各種のトークンとグループ化に対応する意味値により、
 4147: 各種のグループ化が認識されるときに、決定されます。
 4148: 
 4149: @c For example, the calculator calculates properly because the value
 4150: @c associated with each expression is the proper number; it adds properly
 4151: @c because the action for the grouping @w{@samp{@var{x} + @var{y}}} is to add
 4152: @c the numbers associated with @var{x} and @var{y}.
 4153: 
 4154: 電卓の例では、式のそれぞれに対応する値が適切な数値なので、
 4155: 電卓は正確に計算できます。
 4156: グループ@w{@samp{@var{x} + @var{y}}}に
 4157: 対応するアクションが、@var{x}と@var{y}に関する数値の和を計算します。
 4158: 
 4159: @menu
 4160: * Value Type::        Specifying one data type for all semantic values.
 4161: * Multiple Types::    Specifying several alternative data types.
 4162: * Actions::           An action is the semantic definition of a grammar rule.
 4163: * Action Types::      Specifying data types for actions to operate on.
 4164: * Mid-Rule Actions::  Most actions go at the end of a rule.
 4165:                       This says when, why and how to use the exceptional
 4166:                         action in the middle of a rule.
 4167: @end menu
 4168: 
 4169: 
 4170: @c =====================================================================
 4171: @node Value Type, Multiple Types,  , Semantics
 4172: @c @subsection Data Types of Semantic Values
 4173: @subsection データ型と意味値
 4174: @cindex semantic value type
 4175: @cindex value type, semantic
 4176: @cindex data types of semantic values
 4177: @cindex default data type
 4178: @cindex 意味値型
 4179: @cindex 値型, 意味
 4180: @cindex 意味値のデータ型
 4181: @cindex 省略時データ型
 4182: 
 4183: @c In a simple program it may be sufficient to use the same data type for
 4184: @c the semantic values of all language constructs.  This was true in the
 4185: @c RPN and infix calculator examples
 4186: @c (@pxref{RPN Calc, ,Reverse Polish Notation Calculator}).
 4187: 
 4188: 単純なプログラムでは、言語の要素のすべての意味値に対して同じデータ型を
 4189: 使えば十分です。
 4190: 逆ポーランド記法と中間記法電卓の例では、そうでした
 4191: (@pxref{RPN Calc, ,Reverse Polish Notation Calculator})。
 4192: 
 4193: @c Bison's default is to use type @code{int} for all semantic values.  To
 4194: @c specify some other type, define @code{YYSTYPE} as a macro, like this:
 4195: 
 4196: 特に指定しないと、Bisonはすべての意味値に対して@code{int}型を使います。
 4197: 他の型を使うには、次の例のように、マクロ@code{YYSTYPE}を定義します。
 4198: 
 4199: @example
 4200: #define YYSTYPE double
 4201: @end example
 4202: 
 4203: @c @noindent
 4204: @c This macro definition must go in the C declarations section of the grammar
 4205: @c file (@pxref{Grammar Outline, ,Outline of a Bison Grammar}).
 4206: 
 4207: このマクロ定義は、文法ファイルのC宣言部に置く必要があります
 4208: (@pxref{Grammar Outline, ,Outline of a Bison Grammar})。
 4209: 
 4210: 
 4211: @c =====================================================================
 4212: @node Multiple Types, Actions, Value Type, Semantics
 4213: @c @subsection More Than One Value Type
 4214: @subsection 複数の値型
 4215: 
 4216: @c In most programs, you will need different data types for different kinds
 4217: @c of tokens and groupings.  For example, a numeric constant may need type
 4218: @c @code{int} or @code{long}, while a string constant needs type @code{char *},
 4219: @c and an identifier might need a pointer to an entry in the symbol table.
 4220: 
 4221: 多くのプログラムでは、異なる種類のトークンとグループに対して、
 4222: 異なるデータ型が必要です。
 4223: たとえば、数値定数は@code{int}型や@code{long}型を必要とし、
 4224: 文字列定数は@code{char *}型を必要とし、
 4225: 識別子は記号表の項目へのポインタを必要とするでしょう。
 4226: 
 4227: @c To use more than one data type for semantic values in one parser, Bison
 4228: @c requires you to do two things:
 4229: 
 4230: 同一の構文解析器内で、意味値に対して2つ以上のデータ型を使うには、
 4231: 次の2項目が必要です。
 4232: 
 4233: @itemize @bullet
 4234: @item
 4235: @c Specify the entire collection of possible data types, with the
 4236: @c @code{%union} Bison declaration
 4237: @c (@pxref{Union Decl, ,The Collection of Value Types}).
 4238: @c
 4239: Bison宣言の@code{%union}で、考えられるデータ型全体の集合を指定します
 4240: (@pxref{Union Decl, ,The Collection of Value Types})。
 4241: 
 4242: @item
 4243: @c Choose one of those types for each symbol (terminal or nonterminal)
 4244: @c for which semantic values are used.  This is done for tokens with the
 4245: @c @code{%token} Bison declaration
 4246: @c (@pxref{Token Decl, ,Token Type Names}) and for groupings
 4247: @c with the @code{%type} Bison declaration
 4248: @c (@pxref{Type Decl, ,Nonterminal Symbols}).
 4249: @c
 4250: 終端または非終端記号のそれぞれについて、
 4251: その意味値を使うために、上記の型のどれか1つを選びます。
 4252: トークンに対する型の指定には、Bison宣言の@code{%token}を使います
 4253: (@pxref{Token Decl, ,Token Type Names})。
 4254: グループ化に対する型の指定には、Bison宣言の@code{%type}を使います
 4255: (@pxref{Type Decl, ,Nonterminal Symbols})。
 4256: @end itemize
 4257: 
 4258: 
 4259: @c =====================================================================
 4260: @node Actions, Action Types, Multiple Types, Semantics
 4261: @c @subsection Actions
 4262: @subsection アクション
 4263: @cindex action
 4264: @cindex アクション
 4265: @vindex $$
 4266: @vindex $@var{n}
 4267: 
 4268: @c An action accompanies a syntactic rule and contains C code to be executed
 4269: @c each time an instance of that rule is recognized.  The task of most actions
 4270: @c is to compute a semantic value for the grouping built by the rule from the
 4271: @c semantic values associated with tokens or smaller groupings.
 4272: 
 4273: 文法規則にともなうアクションは、その規則が認識されるたびに実行される
 4274: Cのプログラムからなります。
 4275: アクションの仕事のほとんどは、関連するトークンまたは小さいグループから
 4276: 規則にしたがって構成されるグループの、意味値の計算です。
 4277: 
 4278: @c An action consists of C statements surrounded by braces, much like a
 4279: @c compound statement in C.  It can be placed at any position in the rule; it
 4280: @c is executed at that position.  Most rules have just one action at the end
 4281: @c of the rule, following all the components.  Actions in the middle of a rule
 4282: @c are tricky and used only for special
 4283: @c purposes (@pxref{Mid-Rule Actions, ,Actions in Mid-Rule}).
 4284: 
 4285: アクションは、Cの複文のように、ブレースで囲まれたCの文からなります。
 4286: アクションは、規則のどの場所にも置け、その場所で実行されます。
 4287: 規則のほとんどは、規則の終わりの構成要素の並びの後に、
 4288: 1つだけアクションを持ちます。
 4289: 規則の途中に置かれたアクションは、手の込んだ方法で特別な目的に使われます
 4290: (@pxref{Mid-Rule Actions, ,Actions in Mid-Rule})。
 4291: 
 4292: @c The C code in an action can refer to the semantic values of the components
 4293: @c matched by the rule with the construct @code{$@var{n}}, which stands for
 4294: @c the value of the @var{n}th component.  The semantic value for the grouping
 4295: @c being constructed is @code{$$}.  (Bison translates both of these constructs
 4296: @c into array element references when it copies the actions into the parser
 4297: @c file.)
 4298: 
 4299: アクションの中のCで書かれたプログラムは、
 4300: 規則の第@var{n}番目の要素に対応する意味値を、
 4301: @code{$@var{n}}という書式で参照できます。
 4302: また、その規則が構成するグループの意味値を、
 4303: @code{$$}という書式で参照できます。
 4304: アクションが構文解析器ファイルに複写されるときに、Bisonは、
 4305: 上記の構成要素を配列要素への参照に変換します。
 4306: 
 4307: @c Here is a typical example:
 4308: 
 4309: 例を示します。
 4310: 
 4311: @example
 4312: @group
 4313: exp:    @dots{}
 4314:         | exp '+' exp
 4315:             @{ $$ = $1 + $3; @}
 4316: @end group
 4317: @end example
 4318: 
 4319: @c @noindent
 4320: @c This rule constructs an @code{exp} from two smaller @code{exp} groupings
 4321: @c connected by a plus-sign token.  In the action, @code{$1} and @code{$3}
 4322: @c refer to the semantic values of the two component @code{exp} groupings,
 4323: @c which are the first and third symbols on the right hand side of the rule.
 4324: @c The sum is stored into @code{$$} so that it becomes the semantic value of
 4325: @c the addition-expression just recognized by the rule.  If there were a
 4326: @c useful semantic value associated with the @samp{+} token, it could be
 4327: @c referred to as @code{$2}.@refill
 4328: 
 4329: この規則は、加算記号で結び付けられた2つの小さい@code{exp}グループから、
 4330: 1つの@code{exp}を構成します。
 4331: このアクションの中で、@code{$1}と@code{$3}は、
 4332: 規則の右側の最初と3番目の記号である@code{exp}グループの
 4333: 意味値を参照します。
 4334: この規則によって認識される加算式の値になるように、
 4335: 和が@code{$$}に代入されます。
 4336: もし、@samp{+}トークンに有用な値があるならば、
 4337: それを@code{$2}として参照できるでしょう。
 4338: 
 4339: @cindex default action
 4340: @cindex 省略時アクション
 4341: 
 4342: @c If you don't specify an action for a rule, Bison supplies a default:
 4343: @c @w{@code{$$ = $1}.}  Thus, the value of the first symbol in the rule becomes
 4344: @c the value of the whole rule.  Of course, the default rule is valid only
 4345: @c if the two data types match.  There is no meaningful default action for
 4346: @c an empty rule; every empty rule must have an explicit action unless the
 4347: @c rule's value does not matter.
 4348: 
 4349: 規則に対してアクションを指定しなければ、Bisonは、
 4350: 省略時アクション@w{@code{$$ = $1}}を補います。
 4351: したがって、規則の最初の記号の値が規則全体の値になります。
 4352: もちろん、両者の型が一致する場合にのみ、省略時アクションは有効です。
 4353: 空規則に対する省略時アクションは無意味です。
 4354: すべての空規則は、その規則の値が必要ならば、
 4355: 明示的なアクションを持つ必要があります。
 4356: 
 4357: @c @code{$@var{n}} with @var{n} zero or negative is allowed for reference
 4358: @c to tokens and groupings on the stack @emph{before} those that match the
 4359: @c current rule.  This is a very risky practice, and to use it reliably
 4360: @c you must be certain of the context in which the rule is applied.  Here
 4361: @c is a case in which you can use this reliably:
 4362: 
 4363: @code{$@var{n}}の@var{n}は0または負が許され、
 4364: 現在の規則にマッチする@emph{前に}スタックに積まれていた
 4365: トークンとグループの意味値を参照します。
 4366: これは非常に危険な手法で、安全に使うためには、
 4367: その規則が適用される文脈をあなたが完全に理解している必要があります。
 4368: これを安全に使える例を示します。
 4369: 
 4370: @example
 4371: @group
 4372: foo:      expr bar '+' expr  @{ @dots{} @}
 4373:         | expr bar '-' expr  @{ @dots{} @}
 4374:         ;
 4375: @end group
 4376: 
 4377: @group
 4378: @c bar:      /* empty */
 4379: bar:      /* 空 */
 4380:         @{ previous_expr = $0; @}
 4381:         ;
 4382: @end group
 4383: @end example
 4384: 
 4385: @c As long as @code{bar} is used only in the fashion shown here, @code{$0}
 4386: @c always refers to the @code{expr} which precedes @code{bar} in the
 4387: @c definition of @code{foo}.
 4388: 
 4389: @code{bar}がここに書かれた方法でのみ使われるならば、
 4390: @code{foo}の定義の中で@code{bar}より前の
 4391: @code{expr}の値を@code{$0}が参照します。
 4392: 
 4393: 
 4394: @c =====================================================================
 4395: @node Action Types, Mid-Rule Actions, Actions, Semantics
 4396: @c @subsection Data Types of Values in Actions
 4397: @subsection アクション中の値のデータ型
 4398: @cindex action data types
 4399: @cindex data types in actions
 4400: @cindex アクションのデータ型
 4401: @cindex データ型, アクション
 4402: 
 4403: @c If you have chosen a single data type for semantic values, the @code{$$}
 4404: @c and @code{$@var{n}} constructs always have that data type.
 4405: 
 4406: すべての意味値に対して同一のデータ型を使っているのならば、
 4407: @code{$$}と@code{$@var{n}}はそのデータ型を持ちます。
 4408: 
 4409: @c If you have used @code{%union} to specify a variety of data types, then you
 4410: @c must declare a choice among these types for each terminal or nonterminal
 4411: @c symbol that can have a semantic value.  Then each time you use @code{$$} or
 4412: @c @code{$@var{n}}, its data type is determined by which symbol it refers to
 4413: @c in the rule.  In this example,@refill
 4414: 
 4415: さまざまなデータ型を指定するために@code{%union}を使っているならば、
 4416: 意味値を持つ終端記号と非終端記号のそれぞれに対して、
 4417: データ型の中から適切なものを選ぶように宣言する必要があります。
 4418: すると、@code{$$}と@code{@var{n}}を使うたびに、
 4419: 規則の中でそれらがどの記号を参照するかに応じて、
 4420: データ型が決められます。
 4421: 例を示します。
 4422: 
 4423: @example
 4424: @group
 4425: exp:    @dots{}
 4426:         | exp '+' exp
 4427:             @{ $$ = $1 + $3; @}
 4428: @end group
 4429: @end example
 4430: 
 4431: @c @noindent
 4432: @c @code{$1} and @code{$3} refer to instances of @code{exp}, so they all
 4433: @c have the data type declared for the nonterminal symbol @code{exp}.  If
 4434: @c @code{$2} were used, it would have the data type declared for the
 4435: @c terminal symbol @code{'+'}, whatever that might be.@refill
 4436: 
 4437: @code{$1}と@code{$3}は@code{exp}という種類の記号を参照するので、
 4438: @code{$1}と@code{$3}は、非終端記号@code{exp}に対して宣言された
 4439: データ型を持ちます。
 4440: もし、@code{$2}が使われるならば、どのような型であれ、
 4441: 終端記号@code{+}に対して宣言されたデータ型が使われます。
 4442: 
 4443: @c Alternatively, you can specify the data type when you refer to the value,
 4444: @c by inserting @samp{<@var{type}>} after the @samp{$} at the beginning of the
 4445: @c reference.  For example, if you have defined types as shown here:
 4446: 
 4447: 別の方法として、値を参照するときにそのデータ型を指定できます。
 4448: そのためには、参照のための@samp{$}記号の後に@samp{<@var{type}>}を
 4449: 挿入します。例を示します。
 4450: 
 4451: @example
 4452: @group
 4453: %union @{
 4454:   int itype;
 4455:   double dtype;
 4456: @}
 4457: @end group
 4458: @end example
 4459: 
 4460: @c @noindent
 4461: @c then you can write @code{$<itype>1} to refer to the first subunit of the
 4462: @c rule as an integer, or @code{$<dtype>1} to refer to it as a double.
 4463: 
 4464: この場合に、@code{$<itype>1}と書けば、
 4465: 最初の要素を@code{int}型として参照でき、@code{$<dtype>1}と書けば、
 4466: @code{double}型として参照できます。
 4467: 
 4468: 
 4469: @c =====================================================================
 4470: @node Mid-Rule Actions,  , Action Types, Semantics
 4471: @c @subsection Actions in Mid-Rule
 4472: @subsection 規則の途中のアクション
 4473: @cindex actions in mid-rule
 4474: @cindex mid-rule actions
 4475: @cindex 規則の途中のアクション
 4476: @cindex アクション, 規則の途中
 4477: 
 4478: @c Occasionally it is useful to put an action in the middle of a rule.
 4479: @c These actions are written just like usual end-of-rule actions, but they
 4480: @c are executed before the parser even recognizes the following components.
 4481: 
 4482: まれに、アクションを規則の途中に置くと便利な場合があります。
 4483: これらのアクションは、通常の規則の終わりに置かれたアクションと同様に
 4484: 記述されますが、構文解析器が後に続く要素を認識する前に実行されます。
 4485: 
 4486: @c A mid-rule action may refer to the components preceding it using
 4487: @c @code{$@var{n}}, but it may not refer to subsequent components because
 4488: @c it is run before they are parsed.
 4489: 
 4490: 規則の途中のアクションは、そのアクションよりも前にある要素を
 4491: @code{$@var{n}}を使って参照できますが、後に続く要素は
 4492: まだ構文解析されていないので参照できません。
 4493: 
 4494: @c The mid-rule action itself counts as one of the components of the rule.
 4495: @c This makes a difference when there is another action later in the same rule
 4496: @c (and usually there is another at the end): you have to count the actions
 4497: @c along with the symbols when working out which number @var{n} to use in
 4498: @c @code{$@var{n}}.
 4499: 
 4500: 規則の途中のアクション自身は、規則の要素の1つとして数えられます。
 4501: 同じ規則の中に別のアクションが続く場合(通常は最後)に問題が起きます。
 4502: @code{$@var{n}}に使う番号@var{n}に
 4503: 規則の途中のアクションを数えるのを忘れないように注意してください。
 4504: 
 4505: @c The mid-rule action can also have a semantic value.  The action can set
 4506: @c its value with an assignment to @code{$$}, and actions later in the rule
 4507: @c can refer to the value using @code{$@var{n}}.  Since there is no symbol
 4508: @c to name the action, there is no way to declare a data type for the value
 4509: @c in advance, so you must use the @samp{$<@dots{}>} construct to specify a
 4510: @c data type each time you refer to this value.
 4511: 
 4512: 規則の途中のアクションは、意味値を持てます。
 4513: そのアクションは、@code{$$}への代入で値を定め、
 4514: 後に続くアクションの中で、@code{$@var{n}}で値を参照できます。
 4515: アクションに記号名を対応させる方法がないので、
 4516: アクションのデータ型を宣言できません。
 4517: そこで、アクションの意味を参照するときに、
 4518: @samp{$<@dots{}>}を使ってデータ型を指定する必要があります。
 4519: 
 4520: @c There is no way to set the value of the entire rule with a mid-rule
 4521: @c action, because assignments to @code{$$} do not have that effect.  The
 4522: @c only way to set the value for the entire rule is with an ordinary action
 4523: @c at the end of the rule.
 4524: 
 4525: 
 4526: 規則の途中のアクションでは、@code{$$}への代入が規則の値に関係しないので、
 4527: 規則全体の値を設定する方法はありません。
 4528: 規則全体の値を設定する唯一の方法は、
 4529: 規則の最後に置かれた通常のアクションです。
 4530: 
 4531: @c Here is an example from a hypothetical compiler, handling a @code{let}
 4532: @c statement that looks like @samp{let (@var{variable}) @var{statement}} and
 4533: @c serves to create a variable named @var{variable} temporarily for the
 4534: @c duration of @var{statement}.  To parse this construct, we must put
 4535: @c @var{variable} into the symbol table while @var{statement} is parsed, then
 4536: @c remove it afterward.  Here is how it is done:
 4537: 
 4538: 架空のコンパイラの例を示します。
 4539: ここでは、@samp{let (@var{variable}) @var{statement}}のような書式の
 4540: @code{let}文を使え、@var{statement}の持続期間中に一時的に
 4541: @var{variable}という名前の変数を作ります。
 4542: これを構文解析するために、@var{statement}を解析している間、
 4543: @var{variable}を記号表に置いておき、
 4544: 後で記号表から削除する必要があります。
 4545: これを実現する方法を示します。
 4546: 
 4547: @example
 4548: @group
 4549: stmt:   LET '(' var ')'
 4550:                 @{ $<context>$ = push_context ();
 4551:                   declare_variable ($3); @}
 4552:         stmt    @{ $$ = $6;
 4553:                   pop_context ($<context>5); @}
 4554: @end group
 4555: @end example
 4556: 
 4557: @c @noindent
 4558: @c As soon as @samp{let (@var{variable})} has been recognized, the first
 4559: @c action is run.  It saves a copy of the current semantic context (the
 4560: @c list of accessible variables) as its semantic value, using alternative
 4561: @c @code{context} in the data-type union.  Then it calls
 4562: @c @code{declare_variable} to add the new variable to that list.  Once the
 4563: @c first action is finished, the embedded statement @code{stmt} can be
 4564: @c parsed.  Note that the mid-rule action is component number 5, so the
 4565: @c @samp{stmt} is component number 6.
 4566: 
 4567: @samp{let (@var{variable})}が認識されるとすぐに、
 4568: 最初のアクションが実行されます。
 4569: そのアクションは、現在の意味文脈、すなわち参照可能な変数の表の複製を、
 4570: データ型共用体の中の@code{context}型で、
 4571: アクションの意味値として保存します。
 4572: そして、@code{declare_variable}を呼び出して、
 4573: 新しい変数を記号表に追加します。
 4574: 最初のアクションが終わると、後続する@code{stmt}の解析が可能になります。
 4575: 規則の途中のアクションが5番目の要素であることに注意してください。
 4576: したがって、@samp{stmt}は6番目の要素になります。
 4577: 
 4578: @c After the embedded statement is parsed, its semantic value becomes the
 4579: @c value of the entire @code{let}-statement.  Then the semantic value from the
 4580: @c earlier action is used to restore the prior list of variables.  This
 4581: @c removes the temporary @code{let}-variable from the list so that it won't
 4582: @c appear to exist while the rest of the program is parsed.
 4583: 
 4584: 後続する文が解析されると、その意味値が@code{let}文全体の意味値になります。
 4585: そして、最初のアクションの意味値は、
 4586: 変数の表を元に戻すために使われます。
 4587: そこで、@code{let}文中での一時変数が表から削除され、
 4588: 構文解析されるプログラムの残りの部分では一時変数が存在しません。
 4589: 
 4590: @c Taking action before a rule is completely recognized often leads to
 4591: @c conflicts since the parser must commit to a parse in order to execute the
 4592: @c action.  For example, the following two rules, without mid-rule actions,
 4593: @c can coexist in a working parser because the parser can shift the open-brace
 4594: @c token and look at what follows before deciding whether there is a
 4595: @c declaration or not:
 4596: 
 4597: 構文解析器は、アクションを実行する順序を決めるために、
 4598: 構文解析する必要があるので、
 4599: 規則が完全に認識される前にアクションを実行することは、
 4600: しばしば不整合を起こします。
 4601: たとえば、後述の2個の規則は、規則の途中のアクションを持たないので、
 4602: 実行可能な構文解析器の中で共存できます。
 4603: それは、構文解析器は開きブレーストークンをシフトでき、
 4604: 宣言があるかどうか調べるために後に続くものを先読みできるからです。
 4605: 
 4606: @example
 4607: @group
 4608: compound: '@{' declarations statements '@}'
 4609:         | '@{' statements '@}'
 4610:         ;
 4611: @end group
 4612: @end example
 4613: 
 4614: @c @noindent
 4615: @c But when we add a mid-rule action as follows, the rules become nonfunctional:
 4616: しかし、次の例のように、規則の途中のアクションを加えると、
 4617: この規則は働かなくなります。
 4618: 
 4619: @example
 4620: @group
 4621: compound: @{ prepare_for_local_variables (); @}
 4622:           '@{' declarations statements '@}'
 4623: @end group
 4624: @group
 4625:         | '@{' statements '@}'
 4626:         ;
 4627: @end group
 4628: @end example
 4629: 
 4630: @c @noindent
 4631: @c Now the parser is forced to decide whether to run the mid-rule action
 4632: @c when it has read no farther than the open-brace.  In other words, it
 4633: @c must commit to using one rule or the other, without sufficient
 4634: @c information to do it correctly.  (The open-brace token is what is called
 4635: @c the @dfn{look-ahead} token at this time, since the parser is still
 4636: @c deciding what to do about it.  @xref{Look-Ahead, ,Look-Ahead Tokens}.)
 4637: 
 4638: ここでは、開きブレースを見つけた時点で、
 4639: 規則の途中のアクションを実行する必要があるかどうかの決定を迫られます。
 4640: 言い換えれば、正しく判断するための十分な情報なしに、
 4641: ある規則か別の規則のどちらかにゆだねる必要があります。
 4642: 開きブレーストークンは、これを読んだ時点では構文解析器が
 4643: 何をすべきか決定する途中なので、@dfn{先読み(look-ahead)}トークンと
 4644: 呼ばれます。@xref{Look-Ahead, ,Look-Ahead Tokens}。
 4645: 
 4646: @c You might think that you could correct the problem by putting identical
 4647: @c actions into the two rules, like this:
 4648: 
 4649: 次のように同一のアクションを置くことで、
 4650: この問題を解決できるように思えるかもしれません。
 4651: 
 4652: @example
 4653: @group
 4654: compound: @{ prepare_for_local_variables (); @}
 4655:           '@{' declarations statements '@}'
 4656:         | @{ prepare_for_local_variables (); @}
 4657:           '@{' statements '@}'
 4658:         ;
 4659: @end group
 4660: @end example
 4661: 
 4662: @c @noindent
 4663: @c But this does not help, because Bison does not realize that the two actions
 4664: @c are identical.  (Bison never tries to understand the C code in an action.)
 4665: 
 4666: しかし、Bisonには2つのアクションが同一であるかどうかわからないので、
 4667: 問題は解決しません。
 4668: Bisonは、アクションの中のCで書かれたプログラムを、
 4669: 決して解釈しようとしません。
 4670: 
 4671: @c If the grammar is such that a declaration can be distinguished from a
 4672: @c statement by the first token (which is true in C), then one solution which
 4673: @c does work is to put the action after the open-brace, like this:
 4674: 
 4675: C言語のように、最初のトークンによって文と宣言を区別できるような
 4676: 文法ならば、実現可能な解決方法の1つは、次の例のように、
 4677: 開きブレースの後にアクションを置くことです。
 4678: 
 4679: @example
 4680: @group
 4681: compound: '@{' @{ prepare_for_local_variables (); @}
 4682:           declarations statements '@}'
 4683:         | '@{' statements '@}'
 4684:         ;
 4685: @end group
 4686: @end example
 4687: 
 4688: @c @noindent
 4689: @c Now the first token of the following declaration or statement,
 4690: @c which would in any case tell Bison which rule to use, can still do so.
 4691: 
 4692: これで、続く宣言または文の最初のトークンによって、
 4693: Bisonがどちらの規則を使うべきかわかります。
 4694: 
 4695: @c Another solution is to bury the action inside a nonterminal symbol which
 4696: @c serves as a subroutine:
 4697: 
 4698: 別の解決方法は、サブルーチンとして働く非終端記号の内側に、
 4699: アクションを埋め込むことです。
 4700: 
 4701: @example
 4702: @group
 4703: @c subroutine: /* empty */
 4704: subroutine: /* 空 */
 4705:           @{ prepare_for_local_variables (); @}
 4706:         ;
 4707: 
 4708: @end group
 4709: 
 4710: @group
 4711: compound: subroutine
 4712:           '@{' declarations statements '@}'
 4713:         | subroutine
 4714:           '@{' statements '@}'
 4715:         ;
 4716: @end group
 4717: @end example
 4718: 
 4719: @c @noindent
 4720: @c Now Bison can execute the action in the rule for @code{subroutine} without
 4721: @c deciding which rule for @code{compound} it will eventually use.  Note that
 4722: @c the action is now at the end of its rule.  Any mid-rule action can be
 4723: @c converted to an end-of-rule action in this way, and this is what Bison
 4724: @c actually does to implement mid-rule actions.
 4725: 
 4726: これで、Bisonは@code{compound}に対してどちらの規則を使うべきか決めずに、
 4727: @code{subroutine}に対する規則中のアクションを実行できます。
 4728: 任意の規則中のアクションは、この方法によって、
 4729: 規則の最後のアクションに変換できます。
 4730: 実際に、Bisonの内部では、このようにして、
 4731: 規則中のアクションという機能が実現されています。
 4732: 
 4733: 
 4734: @c =====================================================================
 4735: @node Declarations, Multiple Parsers, Semantics, Grammar File
 4736: @c @section Bison Declarations
 4737: @section Bison宣言
 4738: @cindex declarations, Bison
 4739: @cindex Bison declarations
 4740: @cindex 宣言, Bison
 4741: @cindex Bison宣言
 4742: 
 4743: @c The @dfn{Bison declarations} section of a Bison grammar defines the symbols
 4744: @c used in formulating the grammar and the data types of semantic values.
 4745: @c @xref{Symbols}.
 4746: 
 4747: Bison文法ファイルの@dfn{Bison宣言(Bison declarations)}部では、
 4748: 文法の定式化に使う記号を定義し、意味値のデータ型を定義します。
 4749: @xref{Symbols}。
 4750: 
 4751: @c All token type names (but not single-character literal tokens such as
 4752: @c @code{'+'} and @code{'*'}) must be declared.  Nonterminal symbols must be
 4753: @c declared if you need to specify which data type to use for the semantic
 4754: @c value (@pxref{Multiple Types, ,More Than One Value Type}).
 4755: 
 4756: @code{'+'}や@code{'*'}のような1文字リテラルトークンを除く
 4757: すべてのトークンの型名を宣言する必要があります。
 4758: 非終端記号については、その意味値に対してどのデータ型を使うか
 4759: 指定したければ、宣言する必要があります
 4760: (@pxref{Multiple Types, ,More Than One Value Type})。
 4761: 
 4762: @c The first rule in the file also specifies the start symbol, by default.
 4763: @c If you want some other symbol to be the start symbol, you must declare
 4764: @c it explicitly
 4765: @c (@pxref{Language and Grammar, ,Languages and Context-Free Grammars}).
 4766: 
 4767: 特に指定しないと、文法ファイル中の最初の規則は、
 4768: 開始記号を特定します。
 4769: 他の記号を開始記号にしたければ、明示的に宣言する必要があります
 4770: (@pxref{Language and Grammar, ,Languages and Context-Free Grammars})。
 4771: 
 4772: @menu
 4773: * Token Decl::        Declaring terminal symbols.
 4774: * Precedence Decl::   Declaring terminals with precedence and associativity.
 4775: * Union Decl::        Declaring the set of all semantic value types.
 4776: * Type Decl::         Declaring the choice of type for a nonterminal symbol.
 4777: * Expect Decl::       Suppressing warnings about shift/reduce conflicts.
 4778: * Start Decl::        Specifying the start symbol.
 4779: * Pure Decl::         Requesting a reentrant parser.
 4780: * Decl Summary::      Table of all Bison declarations.
 4781: @end menu
 4782: 
 4783: 
 4784: @c =====================================================================
 4785: @node Token Decl, Precedence Decl,  , Declarations
 4786: @c @subsection Token Type Names
 4787: @subsection トークン型名
 4788: @cindex declaring token type names
 4789: @cindex token type names, declaring
 4790: @cindex declaring literal string tokens
 4791: @findex %token
 4792: @cindex トークン型名の宣言
 4793: @cindex トークン型名, 宣言
 4794: @cindex リテラル文字列トークンの宣言
 4795: 
 4796: @c The basic way to declare a token type name (terminal symbol) is as follows:
 4797: 
 4798: トークン型名、すなわち終端記号を、基本的には次のように宣言します。
 4799: 
 4800: @example
 4801: %token @var{name}
 4802: @end example
 4803: 
 4804: @c Bison will convert this into a @code{#define} directive in
 4805: @c the parser, so that the function @code{yylex} (if it is in this file)
 4806: @c can use the name @var{name} to stand for this token type's code.
 4807: 
 4808: Bisonは、これを、構文解析器の中の@code{#define}ディレクティブに変換します。
 4809: したがって、関数@code{yylex}が構文解析器ファイルの中にあれば、
 4810: そこで名前@var{name}をこのトークン型を表すために使えます。
 4811: 
 4812: @c Alternatively, you can use @code{%left}, @code{%right}, or @code{%nonassoc}
 4813: @c instead of @code{%token}, if you wish to specify precedence.
 4814: @c @xref{Precedence Decl, ,Operator Precedence}.
 4815: 
 4816: 優先順位を指定したければ、@code{%token}の代わりに、
 4817: @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。
 4818: @xref{Precedence Decl, ,Operator Precedence}。
 4819: 
 4820: @c You can explicitly specify the numeric code for a token type by appending
 4821: @c an integer value in the field immediately following the token name:
 4822: 
 4823: トークンの名前の直後に整数値を書くことで、
 4824: そのトークン型に対応する数値符号を明示的に指定できます。
 4825: 
 4826: @example
 4827: %token NUM 300
 4828: @end example
 4829: 
 4830: @c @noindent
 4831: @c It is generally best, however, to let Bison choose the numeric codes for
 4832: @c all token types.  Bison will automatically select codes that don't conflict
 4833: @c with each other or with ASCII characters.
 4834: 
 4835: しかし、Bisonにすべてのトークン型に対する数値符号の割り当てをまかせる
 4836: ことがいちばんです。Bisonは、トークン型どうしやASCII文字符号と
 4837: 衝突が起きないように、自動的に数値符号を割り当てます。
 4838: 
 4839: @c In the event that the stack type is a union, you must augment the
 4840: @c @code{%token} or other token declaration to include the data type
 4841: @c alternative delimited by angle-brackets
 4842: @c (@pxref{Multiple Types, ,More Than One Value Type}).  
 4843: 
 4844: スタック型が共用体である場合には、
 4845: @code{%token}あるいは他のトークン宣言に、
 4846: 小なり記号と大なり記号で区切った型名を追加する必要があります
 4847: (@pxref{Multiple Types, ,More Than One Value Type})。
 4848: 
 4849: @c For example:
 4850: 
 4851: 例を示します。
 4852: 
 4853: @example
 4854: @group
 4855: @c %union @{              /* define stack type */
 4856: %union @{              /* スタックのデータ型を定義する */
 4857:   double val;
 4858:   symrec *tptr;
 4859: @}
 4860: @c %token <val> NUM      /* define token NUM and its type */
 4861: %token <val> NUM      /* トークン「NUM」とその型を定義する */
 4862: @end group
 4863: @end example
 4864: 
 4865: @c You can associate a literal string token with a token type name by
 4866: @c writing the literal string at the end of a @code{%token}
 4867: @c declaration which declares the name.  For example:
 4868: 
 4869: トークン型名を宣言する@code{%token}宣言の末尾に
 4870: リテラル文字列を書くことで、リテラル文字列トークンと
 4871: トークン型名を関連づけできます。
 4872: 
 4873: @example
 4874: %token arrow "=>"
 4875: @end example
 4876: 
 4877: @c @noindent
 4878: @c For example, a grammar for the C language might specify these names with
 4879: @c equivalent literal string tokens:
 4880: 
 4881: C言語に対する文法では、次の例のように、
 4882: 等価なリテラル文字列トークンに名前を指定しています。
 4883: 
 4884: @example
 4885: %token  <operator>  OR      "||"
 4886: %token  <operator>  LE 134  "<="
 4887: %left  OR  "<="
 4888: @end example
 4889: 
 4890: @c @noindent
 4891: @c Once you equate the literal string and the token name, you can use them
 4892: @c interchangeably in further declarations or the grammar rules.  The
 4893: @c @code{yylex} function can use the token name or the literal string to
 4894: @c obtain the token type code number (@pxref{Calling Convention}).
 4895: 
 4896: リテラル文字列とトークン名を等価にすれば、それ以降の文法規則の
 4897: 宣言の中で、両者を同様に使えます。
 4898: @code{yylex}関数は、トークン型の数値符号を得るために、
 4899: トークン名とリテラル文字列の両方を使えます
 4900: (@pxref{Calling Convention})。
 4901: 
 4902: 
 4903: @c =====================================================================
 4904: @node Precedence Decl, Union Decl, Token Decl, Declarations
 4905: @c @subsection Operator Precedence
 4906: @subsection 演算子の優先順位
 4907: @cindex precedence declarations
 4908: @cindex declaring operator precedence
 4909: @cindex operator precedence, declaring
 4910: @cindex 優先順位宣言
 4911: @cindex 宣言, 演算子の優先順位
 4912: @cindex 演算子の優先順位
 4913: 
 4914: @c Use the @code{%left}, @code{%right} or @code{%nonassoc} declaration to
 4915: @c declare a token and specify its precedence and associativity, all at
 4916: @c once.  These are called @dfn{precedence declarations}.
 4917: @c @xref{Precedence, ,Operator Precedence},
 4918: @c for general information on operator precedence.
 4919: 
 4920: トークンの宣言とトークンの優先順位および結合規則の指定をまとめて行いたいならば、
 4921: @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。
 4922: これらは、@dfn{優先順位宣言(precedence declarations)}と呼ばれます。
 4923: 演算子の優先順位の詳細については、
 4924: @xref{Precedence, ,Operator Precedence}。
 4925: 
 4926: @c The syntax of a precedence declaration is the same as that of
 4927: @c @code{%token}: either
 4928: 
 4929: 優先順位宣言の構文は、@code{%token}を使う宣言の構文と同じです。
 4930: 
 4931: @example
 4932: %left @var{symbols}@dots{}
 4933: @end example
 4934: 
 4935: @c @noindent
 4936: @c or
 4937: 
 4938: 次のようにも書けます。
 4939: 
 4940: @example
 4941: %left <@var{type}> @var{symbols}@dots{}
 4942: @end example
 4943: 
 4944: @c And indeed any of these declarations serves the purposes of @code{%token}.
 4945: @c But in addition, they specify the associativity and relative precedence for
 4946: @c all the @var{symbols}:
 4947: 
 4948: これらの宣言は、@code{%token}を使う宣言が目的とする
 4949: すべての機能を持っています。
 4950: それに加えて、次のように結合性と、すべての@var{symbols}についての優先順位を指定します。
 4951: 
 4952: @itemize @bullet
 4953: @item
 4954: @c The associativity of an operator @var{op} determines how repeated uses
 4955: @c of the operator nest: whether @samp{@var{x} @var{op} @var{y} @var{op}
 4956: @c @var{z}} is parsed by grouping @var{x} with @var{y} first or by
 4957: @c grouping @var{y} with @var{z} first.  @code{%left} specifies
 4958: @c left-associativity (grouping @var{x} with @var{y} first) and
 4959: @c @code{%right} specifies right-associativity (grouping @var{y} with
 4960: @c @var{z} first).  @code{%nonassoc} specifies no associativity, which
 4961: @c means that @samp{@var{x} @var{op} @var{y} @var{op} @var{z}} is
 4962: @c considered a syntax error.
 4963: @c
 4964: 演算子@var{op}の結合性は、この演算子が繰り返し使われた場合の
 4965: 動作を指定します。つまり、@samp{@var{x} @var{op} @var{y} @var{op} @var{z}}が
 4966: 構文解析された場合に、最初に@var{x}と@var{y}がグループ化されるか、
 4967: それとも@var{y}と@var{z}がグループ化されるかを指定します。
 4968: @code{%left}は、左結合性、つまり@var{x}と@var{y}が先に結合されることを
 4969: 指定します。@code{%right}は、右結合性、つまり、
 4970: @var{y}と@var{z}が先に結合されることを指定します。
 4971: @code{%nonassoc}は、無結合性を指定し、その場合、
 4972: @samp{@var{x} @var{op} @var{y} @var{op} @var{z}}は
 4973: 構文エラーとみなされます。
 4974: 
 4975: @item
 4976: @c The precedence of an operator determines how it nests with other operators.
 4977: @c All the tokens declared in a single precedence declaration have equal
 4978: @c precedence and nest together according to their associativity.
 4979: @c When two tokens declared in different precedence declarations associate,
 4980: @c the one declared later has the higher precedence and is grouped first.
 4981: @c
 4982: 演算子の優先順位は、その演算子が他の演算子とともに使われた場合の
 4983: 動作を指定します。同一の優先順位宣言で宣言されたすべてのトークンは、
 4984: 同じ優先順位を持ち、その結合性にしたがって処理されます。
 4985: 2個のトークンが別々の優先順位宣言で宣言されているならば、
 4986: 文法ファイルの中で後で宣言されたほうの演算子が強い優先順位を持ちます。
 4987: 
 4988: @end itemize
 4989: 
 4990: 
 4991: @c =====================================================================
 4992: @node Union Decl, Type Decl, Precedence Decl, Declarations
 4993: @c @subsection The Collection of Value Types
 4994: @subsection 値型の集合
 4995: @cindex declaring value types
 4996: @cindex value types, declaring
 4997: @findex %union
 4998: @cindex 値型の宣言
 4999: @cindex 宣言, 値型
 5000: 
 5001: @c The @code{%union} declaration specifies the entire collection of possible
 5002: @c data types for semantic values.  The keyword @code{%union} is followed by a
 5003: @c pair of braces containing the same thing that goes inside a @code{union} in
 5004: @c C.  
 5005: 
 5006: @code{%union}宣言は、意味値に対して可能なデータ型すべての集合を指定します。
 5007: キーワード@code{%union}に続いて、C言語における共用体の宣言と同様に、
 5008: ブレースで囲んだ宣言の並びを書きます。
 5009: 
 5010: @c For example:
 5011: 
 5012: 例を示します。
 5013: 
 5014: @example
 5015: @group
 5016: %union @{
 5017:   double val;
 5018:   symrec *tptr;
 5019: @}
 5020: @end group
 5021: @end example
 5022: 
 5023: @c @noindent
 5024: @c This says that the two alternative types are @code{double} and @code{symrec
 5025: @c *}.  They are given names @code{val} and @code{tptr}; these names are used
 5026: @c in the @code{%token} and @code{%type} declarations to pick one of the types
 5027: @c for a terminal or nonterminal symbol
 5028: @c (@pxref{Type Decl, ,Nonterminal Symbols}).
 5029: 
 5030: これは、2つの選択可能な型@code{double}と@code{symrec *}があると、
 5031: 宣言しています。
 5032: それぞれの型には、名前@code{val}と@code{tptr}が与えられています。
 5033: これらの名前は、@code{%token}と@code{type}宣言の中で、
 5034: 終端記号あるいは非終端記号に対する型を選ぶために使えます
 5035: (@pxref{Type Decl, ,Nonterminal Symbols})。
 5036: 
 5037: @c Note that, unlike making a @code{union} declaration in C, you do not write
 5038: @c a semicolon after the closing brace.
 5039: 
 5040: C言語での共用体宣言とは異なり、閉じブレースの後にセミコロンを
 5041: @emph{書いてはいけない}ことに注意してください。
 5042: 
 5043: 
 5044: @c =====================================================================
 5045: @node Type Decl, Expect Decl, Union Decl, Declarations
 5046: @c @subsection Nonterminal Symbols
 5047: @subsection 非終端記号
 5048: @cindex declaring value types, nonterminals
 5049: @cindex value types, nonterminals, declaring
 5050: @findex %type
 5051: @cindex 値型の宣言, 非終端記号
 5052: @cindex 宣言, 非終端記号の値型
 5053: @cindex 非終端記号, 値型の宣言
 5054: 
 5055: @c @noindent
 5056: @c When you use @code{%union} to specify multiple value types, you must
 5057: @c declare the value type of each nonterminal symbol for which values are
 5058: @c used.  This is done with a @code{%type} declaration, like this:
 5059: 
 5060: @code{%union}を複数の値型を指定するために使うならば、
 5061: 値を持つ各非終端記号の値型を宣言する必要があります。
 5062: そのためには、次のように@code{%type}宣言を使います。
 5063: 
 5064: @example
 5065: %type <@var{type}> @var{nonterminal}@dots{}
 5066: @end example
 5067: 
 5068: @c @noindent
 5069: @c Here @var{nonterminal} is the name of a nonterminal symbol, and @var{type}
 5070: @c is the name given in the @code{%union} to the alternative that you want
 5071: @c (@pxref{Union Decl, ,The Collection of Value Types}).
 5072: @c You can give any number of nonterminal symbols in
 5073: @c the same @code{%type} declaration, if they have the same value type.  Use
 5074: @c spaces to separate the symbol names.
 5075: 
 5076: ここで、@var{nonterminal}は非終端記号の名前で、
 5077: @var{type}は@code{%union}で指定した名前の中からあなたが選んだものです
 5078: (@pxref{Union Decl, ,The Collection of Value Types})。
 5079: 同じ値型を持つ任意の数の非終端記号を、
 5080: 1つの@code{%type}宣言の中に記述できます。
 5081: その場合、記号名を空白で区切ってください。
 5082: 
 5083: @c You can also declare the value type of a terminal symbol.  To do this,
 5084: @c use the same @code{<@var{type}>} construction in a declaration for the
 5085: @c terminal symbol.  All kinds of token declarations allow
 5086: @c @code{<@var{type}>}.
 5087: 
 5088: 同様に終端記号の値型の宣言も可能です。
 5089: そのためには、終端記号の宣言の中で、同じ@code{<@var{type}>}の
 5090: 書式を使います。
 5091: すべてのトークン宣言で、@code{<@var{type}>}が許可されています。
 5092: 
 5093: 
 5094: @c =====================================================================
 5095: @node Expect Decl, Start Decl, Type Decl, Declarations
 5096: @c @subsection Suppressing Conflict Warnings
 5097: @subsection 衝突警告の回避
 5098: @cindex suppressing conflict warnings
 5099: @cindex preventing warnings about conflicts
 5100: @cindex warnings, preventing
 5101: @cindex conflicts, suppressing warnings of
 5102: @findex %expect
 5103: @cindex 衝突警告の回避
 5104: @cindex 回避, 衝突警告
 5105: @cindex 警告, 衝突
 5106: @cindex 衝突, 警告の回避
 5107: 
 5108: @c Bison normally warns if there are any conflicts in the grammar
 5109: @c (@pxref{Shift/Reduce, ,Shift/Reduce Conflicts}),
 5110: @c but most real grammars have harmless shift/reduce
 5111: @c conflicts which are resolved in a predictable way and would be difficult to
 5112: @c eliminate.  It is desirable to suppress the warning about these conflicts
 5113: @c unless the number of conflicts changes.  You can do this with the
 5114: @c @code{%expect} declaration.
 5115: 
 5116: 文法の中に衝突(@pxref{Shift/Reduce, ,Shift/Reduce Conflicts})があると、
 5117: Bisonは通常警告を表示します。
 5118: しかし、実際の文法のほとんどは、無害なシフト還元衝突を含み、
 5119: その衝突は、予測可能な方法で回避できますが、除去は困難です。
 5120: 衝突の数が変わらないかぎり、このような衝突の警告は
 5121: 抑制させるべきです。
 5122: そのために、@code{%expect}宣言を使います。
 5123: 
 5124: @c The declaration looks like this:
 5125: 
 5126: 次のように宣言します。
 5127: 
 5128: @example
 5129: %expect @var{n}
 5130: @end example
 5131: 
 5132: @c Here @var{n} is a decimal integer.  The declaration says there should be no
 5133: @c warning if there are @var{n} shift/reduce conflicts and no reduce/reduce
 5134: @c conflicts.  The usual warning is given if there are either more or fewer
 5135: @c conflicts, or if there are any reduce/reduce conflicts.
 5136: 
 5137: ここで、@var{n}は10進の整数です。
 5138: この宣言によって、@var{n}個のシフト還元衝突があって、
 5139: 還元/還元衝突がなければ、警告が表示されません。
 5140: シフト還元衝突の数が@var{n}でなかったり、
 5141: 1つでも還元/還元衝突があった場合は、通常の警告が表示されます。
 5142: 
 5143: @c In general, using @code{%expect} involves these steps:
 5144: 
 5145: 一般に、次のような手順で@code{%expect}を使います。
 5146: 
 5147: @itemize @bullet
 5148: @item
 5149: @c Compile your grammar without @code{%expect}.  Use the @samp{-v} option
 5150: @c to get a verbose list of where the conflicts occur.  Bison will also
 5151: @c print the number of conflicts.
 5152: @c
 5153: @code{%expect}なしで文法ファイルをコンパイルします。
 5154: 衝突が起こる位置の詳細な目録を得るために、@samp{-v}オプションを指定します。
 5155: Bisonは、衝突の数も表示します。
 5156: 
 5157: @item
 5158: @c Check each of the conflicts to make sure that Bison's default
 5159: @c resolution is what you really want.  If not, rewrite the grammar and
 5160: @c go back to the beginning.
 5161: @c
 5162: 衝突のそれぞれについて、Bisonの省略時の解決方法が、
 5163: あなたの望みどおりであるか、確かめます。
 5164: もし不都合があれば、文法ファイルを書き直して、最初に戻ります。
 5165: 
 5166: @item
 5167: @c Add an @code{%expect} declaration, copying the number @var{n} from the
 5168: @c number which Bison printed.
 5169: @c
 5170: Bisonが表示した衝突の数@var{n}を書き写して、
 5171: @code{%expect}宣言を追加します。
 5172: 
 5173: @end itemize
 5174: 
 5175: @c Now Bison will stop annoying you about the conflicts you have checked, but
 5176: @c it will warn you again if changes in the grammar result in additional
 5177: @c conflicts.
 5178: 
 5179: すると、Bisonはチェックした衝突について文句をいわなくなりますが、
 5180: 文法ファイルを書き換えて衝突の数が変わると、
 5181: 再び警告を表示します。
 5182: 
 5183: 
 5184: @c =====================================================================
 5185: @node Start Decl, Pure Decl, Expect Decl, Declarations
 5186: @c @subsection The Start-Symbol
 5187: @subsection 開始記号
 5188: @cindex declaring the start symbol
 5189: @cindex start symbol, declaring
 5190: @cindex default start symbol
 5191: @findex %start
 5192: @cindex 開始記号の宣言
 5193: @cindex 宣言, 開始記号
 5194: @cindex 省略時開始記号
 5195: 
 5196: @c Bison assumes by default that the start symbol for the grammar is the first
 5197: @c nonterminal specified in the grammar specification section.  The programmer
 5198: @c may override this restriction with the @code{%start} declaration as follows:
 5199: 
 5200: Bisonは、文法定義部にある最初の非終端記号を、
 5201: 省略時の開始記号と仮定します。
 5202: 次のような@code{%start}宣言で、明示的に開始記号を指定できます。
 5203: 
 5204: @example
 5205: %start @var{symbol}
 5206: @end example
 5207: 
 5208: 
 5209: @c =====================================================================
 5210: @node Pure Decl, Decl Summary, Start Decl, Declarations
 5211: @c @subsection A Pure (Reentrant) Parser
 5212: @subsection 純粋(再入可能)構文解析器
 5213: @cindex reentrant parser
 5214: @cindex pure parser
 5215: @findex %pure_parser
 5216: @cindex 再入可能構文解析器
 5217: @cindex 純粋構文解析器
 5218: 
 5219: @c A @dfn{reentrant} program is one which does not alter in the course of
 5220: @c execution; in other words, it consists entirely of @dfn{pure} (read-only)
 5221: @c code.  Reentrancy is important whenever asynchronous execution is possible;
 5222: @c for example, a nonreentrant program may not be safe to call from a signal
 5223: @c handler.  In systems with multiple threads of control, a nonreentrant
 5224: @c program must be called only within interlocks.
 5225: 
 5226: @dfn{再入可能(reentrant)}プログラムとは、進路を変えないプログラム、
 5227: いいかえれば、完全に@dfn{純粋な(pure)}(読み出し専用)コードからなる
 5228: プログラムです。
 5229: @footnote{【訳注】ある手続きの終了を待たずに、その手続きを再度呼び出せる
 5230: ことでもあります。}
 5231: 再入可能性は、非同期実行が可能な場合に重要です。
 5232: たとえば、再入可能でないプログラムを、
 5233: シグナルハンドラから呼び出すことは危険です。マルチスレッド制御システムでは、
 5234: 再入不能プログラムはインターロックからしか呼び出せません。
 5235: 
 5236: @c The Bison parser is not normally a reentrant program, because it uses
 5237: @c statically allocated variables for communication with @code{yylex}.  These
 5238: @c variables include @code{yylval} and @code{yylloc}.
 5239: 
 5240: 通常のBison構文解析器は、@code{yylex}と通信するために静的
 5241: @footnote{【訳注】他のソースファイルから見えないとう意味ではなく、
 5242: メモリ上の固定番地に置かれるという意味。}変数を使うので、
 5243: 再入可能プログラムでありません。これらの変数には、
 5244: @code{yylval}と@code{yyloc}が含まれます。
 5245: 
 5246: @c The Bison declaration @code{%pure_parser} says that you want the parser
 5247: @c to be reentrant.  It looks like this:
 5248: 
 5249: 次のような@code{%pure_parser} Bison宣言は、
 5250: 再入可能な構文解析器を生成します。
 5251: 
 5252: @example
 5253: %pure_parser
 5254: @end example
 5255: 
 5256: @c The effect is that the two communication variables become local
 5257: @c variables in @code{yyparse}, and a different calling convention is used
 5258: @c for the lexical analyzer function @code{yylex}.  @xref{Pure Calling,
 5259: @c ,Calling Conventions for Pure Parsers}, for the details of this.  The
 5260: @c variable @code{yynerrs} also becomes local in @code{yyparse}
 5261: @c (@pxref{Error Reporting, ,The Error Reporting Function @code{yyerror}}).
 5262: @c The convention for calling @code{yyparse} itself is unchanged.
 5263: 
 5264: この宣言によって、上記の2個の通信用変数が、@code{yyparse}の局所変数になり、
 5265: @code{yylex}字句解析関数を呼び出す方法が変わります。
 5266: 詳細については、@xref{Pure Calling, ,Calling Conventions for Pure Parsers}。
 5267: @code{yyparse}の中の@code{yynerrs}変数も局所変数になります
 5268: (@pxref{Error Reporting, ,The Error Reporting Function @code{yyerror}})。
 5269: @code{yypase}関数自体を呼び出す方法は変わりません。
 5270: 
 5271: 
 5272: @c =====================================================================
 5273: @node Decl Summary,  , Pure Decl, Declarations
 5274: @c @subsection Bison Declaration Summary
 5275: @subsection Bison宣言の要約
 5276: @cindex Bison declaration summary
 5277: @cindex declaration summary
 5278: @cindex summary, Bison declaration
 5279: @cindex Bison宣言の要約
 5280: @cindex 宣言の要約
 5281: @cindex 要約, Bison宣言
 5282: 
 5283: @c Here is a summary of all Bison declarations:
 5284: 
 5285: Bison宣言の要約を示します。
 5286: 
 5287: @table @code
 5288: @item %union
 5289: @c Declare the collection of data types that semantic values may have
 5290: @c (@pxref{Union Decl, ,The Collection of Value Types}).
 5291: @c
 5292: 意味値が持ちうるデータ型の集合を宣言します
 5293: (@pxref{Union Decl, ,The Collection of Value Types})。
 5294: 
 5295: @item %token
 5296: @c Declare a terminal symbol (token type name) with no precedence
 5297: @c or associativity specified (@pxref{Token Decl, ,Token Type Names}).
 5298: @c
 5299: 優先順位と結合性を指定せずに、終端記号(トークン型名)を宣言します
 5300: (@pxref{Token Decl, ,Token Type Names})。
 5301: 
 5302: @item %right
 5303: @c Declare a terminal symbol (token type name) that is right-associative
 5304: @c (@pxref{Precedence Decl, ,Operator Precedence}).
 5305: @c
 5306: 右結合的な終端記号(トークン型名)を宣言します
 5307: (@pxref{Precedence Decl, ,Operator Precedence})。
 5308: 
 5309: @item %left
 5310: @c Declare a terminal symbol (token type name) that is left-associative
 5311: @c (@pxref{Precedence Decl, ,Operator Precedence}).
 5312: @c
 5313: 左結合的な終端記号(トークン型名)を宣言します
 5314: (@pxref{Precedence Decl, ,Operator Precedence})。
 5315: 
 5316: @item %nonassoc
 5317: @c Declare a terminal symbol (token type name) that is nonassociative
 5318: @c (using it in a way that would be associative is a syntax error)
 5319: @c (@pxref{Precedence Decl, ,Operator Precedence}).
 5320: 結合性がない、つまり、結合して使おうとすると構文エラーになる、
 5321: 終端記号(トークン型名)を宣言します
 5322: (@pxref{Precedence Decl, ,Operator Precedence})。
 5323: 
 5324: @item %type
 5325: @c Declare the type of semantic values for a nonterminal symbol
 5326: @c (@pxref{Type Decl, ,Nonterminal Symbols}).
 5327: @c
 5328: 非終端記号に対する意味値の型を宣言します
 5329: (@pxref{Type Decl, ,Nonterminal Symbols})。
 5330: 
 5331: @item %start
 5332: @c Specify the grammar's start symbol (@pxref{Start Decl, ,The Start-Symbol}).
 5333: @c
 5334: 文法の開始記号を宣言します
 5335: (@pxref{Start Decl, ,The Start-Symbol})。
 5336: 
 5337: @item %expect
 5338: @c Declare the expected number of shift-reduce conflicts
 5339: @c (@pxref{Expect Decl, ,Suppressing Conflict Warnings}).
 5340: @c
 5341: 予想されるシフト還元衝突の数を宣言します
 5342: (@pxref{Expect Decl, ,Suppressing Conflict Warnings})。
 5343: 
 5344: @item %pure_parser
 5345: @c Request a pure (reentrant) parser program
 5346: @c (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).
 5347: @c
 5348: 純粋な(再入可能な)構文解析器を生成します
 5349: (@pxref{Pure Decl, ,A Pure (Reentrant) Parser})。
 5350: 
 5351: @item %no_lines
 5352: @c Don't generate any @code{#line} preprocessor commands in the parser
 5353: @c file.  Ordinarily Bison writes these commands in the parser file so that
 5354: @c the C compiler and debuggers will associate errors and object code with
 5355: @c your source file (the grammar file).  This directive causes them to
 5356: @c associate errors with the parser file, treating it an independent source
 5357: @c file in its own right.
 5358: @c
 5359: 構文解析器ファイルに、@code{#line}プリプロセッサディレクティブを生成しません。
 5360: Bisonは、通常、Cコンパイラとデバッガがエラーとあなたのソースファイル
 5361: (文法ファイル)を関連づけられるように、構文解析器ファイルに
 5362: @code{#line}ディレクティブを書き込みます。
 5363: @code{%no_lines}宣言は、エラーを構文解析器ファイルの行数と関連づけ、
 5364: 構文解析器ファイルをそれ自身で独立したソースファイルと
 5365: みなすことを意味します。
 5366: 
 5367: @item %raw
 5368: @c The output file @file{@var{name}.h} normally defines the tokens with
 5369: @c Yacc-compatible token numbers.  If this option is specified, the
 5370: @c internal Bison numbers are used instead.  (Yacc-compatible numbers start
 5371: @c at 257 except for single character tokens; Bison assigns token numbers
 5372: @c sequentially for all tokens starting at 3.)
 5373: @c
 5374: 通常、出力ファイル@file{@var{name}.h}は、
 5375: Yacc互換トークン番号を定義します。
 5376: このオプションが指定されると、代わりに、Bison内部の番号が使われます
 5377: (Yacc互換番号は、1文字リテラルトークンを除いて、257から始まりますが、
 5378: Bison内部のトークン番号は常に3から始まる連番になります)。
 5379: 
 5380: @item %token_table
 5381: @c Generate an array of token names in the parser file.  The name of the
 5382: @c array is @code{yytname}; @code{yytname[@var{i}]} is the name of the
 5383: @c token whose internal Bison token code number is @var{i}.  The first three
 5384: @c elements of @code{yytname} are always @code{"$"}, @code{"error"}, and
 5385: @c @code{"$illegal"}; after these come the symbols defined in the grammar
 5386: @c file.
 5387: @c 
 5388: 構文解析器ファイルの中に、トークン名の表を生成します。
 5389: その表の名前は@code{yytname}で、@code{yytname[@var{i}]}が
 5390: Bison内部トークン番号@var{i}のトークンの名前です。
 5391: 最初の3個の要素は常に、@code{"$"}、@code{"error"}、@code{"$illegal"}で、
 5392: この後に文法ファイルで定義された記号が続きます。
 5393: 
 5394: @c For single-character literal tokens and literal string tokens, the name
 5395: @c in the table includes the single-quote or double-quote characters: for
 5396: @c example, @code{"'+'"} is a single-character literal and @code{"\"<=\""}
 5397: @c is a literal string token.  All the characters of the literal string
 5398: @c token appear verbatim in the string found in the table; even
 5399: @c double-quote characters are not escaped.  For example, if the token
 5400: @c consists of three characters @samp{*"*}, its string in @code{yytname}
 5401: @c contains @samp{"*"*"}.  (In C, that would be written as
 5402: @c @code{"\"*\"*\""}).
 5403: 
 5404: 表の中で、1文字リテラルトークンにはシングルクォート記号が、
 5405: 文字列リテラルトークンにはダブルクォート記号が含まれます。
 5406: たとえば、@code{"'+'"}は1文字リテラルトークンで、
 5407: @code{"\"<=\""}は文字列リテラルトークンです。
 5408: 文字列リテラルトークンのすべての文字はそのまま表に現れ、
 5409: ダブルクォート記号もエスケープされません。
 5410: たとえば、トークンが3文字@samp{*"*}からなれば、
 5411: @code{yytname}中の文字列は@samp{"*"*"}となります
 5412: (Cでは@code{"\"*\"*\""}と書きます)。
 5413: 
 5414: @c When you specify @code{%token_table}, Bison also generates macro
 5415: @c definitions for macros @code{YYNTOKENS}, @code{YYNNTS}, and
 5416: @c @code{YYNRULES}, and @code{YYNSTATES}:
 5417: @c
 5418: @code{%token_table}を指定すると、Bisonは、マクロ
 5419: @code{YYNTOKENS}、@code{YYNNTS}、@code{YYNRULES}、@code{YYNSTATES}の
 5420: 定義も生成します。
 5421: 
 5422: @table @code
 5423: @item YYNTOKENS
 5424: @c The highest token number, plus one.
 5425: @c
 5426: 最大のトークン番号+1。
 5427: @item YYNNTS
 5428: @c The number of non-terminal symbols.
 5429: 非終端記号の数。
 5430: @item YYNRULES
 5431: @c The number of grammar rules,
 5432: 文法規則の数。
 5433: @item YYNSTATES
 5434: @c The number of parser states (@pxref{Parser States}).
 5435: 構文解析器の状態の数(@pxref{Parser States})。
 5436: @end table
 5437: @end table
 5438: 
 5439: 
 5440: @c =====================================================================
 5441: @node Multiple Parsers,, Declarations, Grammar File
 5442: @c @section Multiple Parsers in the Same Program
 5443: @section 同一プログラム中の複数の構文解析器
 5444: 
 5445: @c Most programs that use Bison parse only one language and therefore contain
 5446: @c only one Bison parser.  But what if you want to parse more than one
 5447: @c language with the same program?  Then you need to avoid a name conflict
 5448: @c between different definitions of @code{yyparse}, @code{yylval}, and so on.
 5449: 
 5450: Bisonを使うプログラムのほとんどは、言語を1つだけ構文解析し、
 5451: したがって、Bison構文解析器を1つだけ含みます。
 5452: しかし、1つのプログラムで2種類以上の言語を構文解析したいときは、
 5453: どうすればよいでしょうか? そうするためには、@code{yyparse}、@code{yylval}
 5454: などの2重定義の衝突を防ぐ必要があります。
 5455: 
 5456: @c The easy way to do this is to use the option @samp{-p @var{prefix}}
 5457: @c (@pxref{Invocation, ,Invoking Bison}). 
 5458: @c This renames the interface functions and
 5459: @c variables of the Bison parser to start with @var{prefix} instead of
 5460: @c @samp{yy}.  You can use this to give each parser distinct names that do
 5461: @c not conflict.
 5462: 
 5463: これを容易にする方法が、オプション@samp{-p @var{prefix}}の利用です
 5464: (@pxref{Invocation, ,Invoking Bison})。
 5465: これによって、Bison構文解析器のインターフェイス関数と変数の名前が、
 5466: @samp{yy}で始まる代わりに@var{prefix}で始まります。
 5467: これでそれぞれの構文解析器に、衝突しないような異なる名前を与えられます。
 5468: 
 5469: @c The precise list of symbols renamed is @code{yyparse}, @code{yylex},
 5470: @c @code{yyerror}, @code{yynerrs}, @code{yylval}, @code{yychar} and
 5471: @c @code{yydebug}.  For example, if you use @samp{-p c}, the names become
 5472: @c @code{cparse}, @code{clex}, and so on.
 5473: 
 5474: 変更される名前は、
 5475: @code{yyparse}、@code{yylex}、@code{yyerror}、@code{yynerrs}、
 5476: @code{yylval}、@code{yychar}、@code{yydebug}で全部です。
 5477: たとえば、@samp{-p c}オプションを使えば、これらの名前は、
 5478: @code{cparse}、@code{clex}などに変わります。
 5479: 
 5480: @c @strong{All the other variables and macros associated with Bison are not
 5481: @c renamed.} These others are not global; there is no conflict if the same
 5482: @c name is used in different parsers.  For example, @code{YYSTYPE} is not
 5483: @c renamed, but defining this in different ways in different parsers causes
 5484: @c no trouble (@pxref{Value Type, ,Data Types of Semantic Values}).
 5485: 
 5486: @strong{Bisonに関連する上記以外の変数とマクロのすべての
 5487: 名前は変わりません。}これらは、広域ではないので、
 5488: 異なる構文解析器で同じ名前が使われても衝突しません。
 5489: たとえば、@code{YYSTYPE}の名前は変わりませんが、
 5490: この定義は構文解析器ごとに異なる方法で行われるので、問題ありません
 5491: (@pxref{Value Type, ,Data Types of Semantic Values})。
 5492: 
 5493: @c The @samp{-p} option works by adding macro definitions to the beginning
 5494: @c of the parser source file, defining @code{yyparse} as
 5495: @c @code{@var{prefix}parse}, and so on.  This effectively substitutes one
 5496: @c name for the other in the entire parser file.
 5497: 
 5498: @samp{-p}オプションは、さらに、構文解析器ソースファイルの始めで、
 5499: @code{yyparse}を@code{@var{prefix}parse}と定義するように、
 5500: マクロを定義します。
 5501: この結果、構文解析器ソースファイル全体で、ある名前を別の名前に変えます。
 5502: 
 5503: 
 5504: @c =====================================================================
 5505: @node Interface, Algorithm, Grammar File, Top
 5506: @c @chapter Parser C-Language Interface
 5507: @chapter 構文解析器のC言語インターフェイス
 5508: @cindex C-language interface
 5509: @cindex interface
 5510: @cindex C言語インターフェイス
 5511: @cindex インターフェイス
 5512: 
 5513: @c The Bison parser is actually a C function named @code{yyparse}.  Here we
 5514: @c describe the interface conventions of @code{yyparse} and the other
 5515: @c functions that it needs to use.
 5516: 
 5517: Bison構文解析器の正体は、@code{yyparse}という名前のCの関数です。
 5518: ここでは、@code{yyparse}とほかに使う必要がある関数の間の
 5519: インターフェイスの方法を示します。
 5520: 
 5521: @c Keep in mind that the parser uses many C identifiers starting with
 5522: @c @samp{yy} and @samp{YY} for internal purposes.  If you use such an
 5523: @c identifier (aside from those in this manual) in an action or in additional
 5524: @c C code in the grammar file, you are likely to run into trouble.
 5525: 
 5526: 構文解析器の内部では、多くの@samp{yy}または@samp{YY}で始まるCの識別子が
 5527: 使われていることに注意してください。
 5528: 本書で説明しているものを除いて、そのような識別子を
 5529: 文法ファイルのアクションや追加のCプログラムの中で使うと、
 5530: 問題が起きるでしょう。
 5531: 
 5532: @menu
 5533: * Parser Function::   How to call @code{yyparse} and what it returns.
 5534: * Lexical::           You must supply a function @code{yylex} 
 5535:                         which reads tokens.
 5536: * Error Reporting::   You must supply a function @code{yyerror}.
 5537: * Action Features::   Special features for use in actions.
 5538: @end menu
 5539: 
 5540: 
 5541: @c =====================================================================
 5542: @node Parser Function, Lexical,  , Interface
 5543: @c @section The Parser Function @code{yyparse}
 5544: @section 構文解析器関数@code{yyparse}
 5545: @findex yyparse
 5546: 
 5547: @c You call the function @code{yyparse} to cause parsing to occur.  This
 5548: @c function reads tokens, executes actions, and ultimately returns when it
 5549: @c encounters end-of-input or an unrecoverable syntax error.  You can also
 5550: @c write an action which directs @code{yyparse} to return immediately without
 5551: @c reading further.
 5552: 
 5553: 構文解析を始めるには、関数@code{yyparse}を呼び出します。
 5554: この関数は、トークンを読み、アクションを実行し、最後には入力ファイルの
 5555: 終わりに達するか回復不可能な構文エラーに達して、戻ります。
 5556: 読み込みを打ち切って@code{yyparse}関数から戻るような
 5557: アクションを書くことも可能です。
 5558: 
 5559: @c The value returned by @code{yyparse} is 0 if parsing was successful (return
 5560: @c is due to end-of-input).
 5561: 
 5562: 構文解析が成功する、つまり入力ファイルの終わりに達すると、
 5563: @code{yyparse}からの戻り値が0になります。
 5564: 
 5565: @c The value is 1 if parsing failed (return is due to a syntax error).
 5566: 
 5567: 構文解析が失敗する、つまり構文エラーが発生すると、
 5568: 戻り値が1になります。
 5569: 
 5570: @c In an action, you can cause immediate return from @code{yyparse} by using
 5571: @c these macros:
 5572: 
 5573: アクションの中で、次のマクロを使って、
 5574: @code{yyparse}からただちに戻れます。
 5575: 
 5576: @table @code
 5577: @item YYACCEPT
 5578: @findex YYACCEPT
 5579: @c Return immediately with value 0 (to report success).
 5580: 成功の印である戻り値0をともなって、ただちに戻ります。
 5581: 
 5582: @item YYABORT
 5583: @findex YYABORT
 5584: @c Return immediately with value 1 (to report failure).
 5585: 失敗の印である戻り値1をともなって、ただちに戻ります。
 5586: 
 5587: @end table
 5588: 
 5589: 
 5590: @c =====================================================================
 5591: @node Lexical, Error Reporting, Parser Function, Interface
 5592: @c @section The Lexical Analyzer Function @code{yylex}
 5593: @section 字句解析器関数@code{yylex}
 5594: @findex yylex
 5595: @cindex lexical analyzer
 5596: @cindex 字句解析器
 5597: 
 5598: @c The @dfn{lexical analyzer} function, @code{yylex}, recognizes tokens from
 5599: @c the input stream and returns them to the parser.  Bison does not create
 5600: @c this function automatically; you must write it so that @code{yyparse} can
 5601: @c call it.  The function is sometimes referred to as a lexical scanner.
 5602: 
 5603: @dfn{字句解析器(lexical analyzer)}関数@code{yylex}は、
 5604: 入力からトークンを認識し、構文解析器に返します。
 5605: Bisonはこの関数を自動的に生成しないので、
 5606: @code{yyparse}から呼び出されるように@code{yylex}を書く必要があります。
 5607: 関数@code{yylex}は``lexical scanner''と呼ばれることもあります。
 5608: 
 5609: @c In simple programs, @code{yylex} is often defined at the end of the Bison
 5610: @c grammar file.  If @code{yylex} is defined in a separate source file, you
 5611: @c need to arrange for the token-type macro definitions to be available there.
 5612: @c To do this, use the @samp{-d} option when you run Bison, so that it will
 5613: @c write these macro definitions into a separate header file
 5614: @c @file{@var{name}.tab.h} which you can include in the other source files
 5615: @c that need it.  @xref{Invocation, ,Invoking Bison}.@refill
 5616: 
 5617: 単純なプログラムでは、よく文法ファイルの最後で@code{yylex}を
 5618: 定義します。@code{yylex}が別のソースファイルの中で定義する場合は、
 5619: そこでトークン型マクロ定義を使えるように準備する必要があります。
 5620: そのためには、@samp{-d}オプションを指定してBisonを実行してください。
 5621: すると、マクロ定義がヘッダファイル@file{@var{name}.tab.h}に
 5622: 書き込まれ、それを必要とするソースファイルにインクルードできます。
 5623: @xref{Invocation, ,Invoking Bison}。
 5624: 
 5625: @menu
 5626: * Calling Convention::  How @code{yyparse} calls @code{yylex}.
 5627: * Token Values::      How @code{yylex} must return the semantic value
 5628:                         of the token it has read.
 5629: * Token Positions::   How @code{yylex} must return the text position
 5630:                         (line number, etc.) of the token, if the
 5631:                         actions want that.
 5632: * Pure Calling::      How the calling convention differs
 5633:                         in a pure parser (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).
 5634: @end menu
 5635: 
 5636: 
 5637: @c =====================================================================
 5638: @node Calling Convention, Token Values,  , Lexical
 5639: @c @subsection Calling Convention for @code{yylex}
 5640: @subsection @code{yylex}を呼び出す方法
 5641: 
 5642: @c The value that @code{yylex} returns must be the numeric code for the type
 5643: @c of token it has just found, or 0 for end-of-input.
 5644: 
 5645: @code{yylex}が返す値は、見つかったトークンの型に対する番号で、
 5646: 入力ファイルの終わりに達した場合には0を返します。
 5647: 
 5648: @c When a token is referred to in the grammar rules by a name, that name
 5649: @c in the parser file becomes a C macro whose definition is the proper
 5650: @c numeric code for that token type.  So @code{yylex} can use the name
 5651: @c to indicate that type.  @xref{Symbols}.
 5652: 
 5653: トークンが文法規則の中で名前で参照される場合、
 5654: 構文解析器ファイルの中でのその名前は、
 5655: トークン型に対する適切な番号にCのマクロとして定義されます。
 5656: したがって、@code{yylex}は型を示すためにその名前を使用できます。
 5657: @xref{Symbols}。
 5658: 
 5659: @c When a token is referred to in the grammar rules by a character literal,
 5660: @c the numeric code for that character is also the code for the token type.
 5661: @c So @code{yylex} can simply return that character code.  The null character
 5662: @c must not be used this way, because its code is zero and that is what
 5663: @c signifies end-of-input.
 5664: 
 5665: 文法規則の中でトークンが1文字リテラルとして参照される場合には、
 5666: その文字の文字符号がトークン型に対する番号でもあります。
 5667: そこで、@code{yylex}は、単純に文字符号を返します。
 5668: しかし、戻り値0は入力ファイルの終わりを意味するので、
 5669: ヌル文字(@code{'\0'})の文字符号を返してはいけません。
 5670: 
 5671: @c Here is an example showing these things:
 5672: 
 5673: 以下に例を示します。
 5674: 
 5675: @example
 5676: yylex ()
 5677: @{
 5678:   @dots{}
 5679: @c   if (c == EOF)     /* Detect end of file. */
 5680:   if (c == EOF)     /* ファイルの終わりか調べる。 */
 5681:     return 0;
 5682:   @dots{}
 5683:   if (c == '+' || c == '-')
 5684: @c     return c;      /* Assume token type for `+' is '+'. */
 5685:     return c;      /* `+' に対するトークン型が '+' であると仮定する。 */
 5686:   @dots{}
 5687: @c   return INT;      /* Return the type of the token. */
 5688:   return INT;      /* トークン型を返す。 */
 5689:   @dots{}
 5690: @}
 5691: @end example
 5692: 
 5693: @c @noindent
 5694: @c This interface has been designed so that the output from the @code{lex}
 5695: @c utility can be used without change as the definition of @code{yylex}.
 5696: 
 5697: このようなインターフェイスは、
 5698: @code{lex}が生成した字句解析器を、
 5699: @code{yylex}の定義を変えずに使えるように設計されています。
 5700: 
 5701: @c If the grammar uses literal string tokens, there are two ways that
 5702: @c @code{yylex} can determine the token type codes for them:
 5703: 
 5704: 文法規則が文字列リテラルトークンを使っている場合には、
 5705: @code{yylex}がそれに対するトークン型番号を使う、
 5706: 2つの方法があります。
 5707: 
 5708: @itemize @bullet
 5709: @item
 5710: @c If the grammar defines symbolic token names as aliases for the
 5711: @c literal string tokens, @code{yylex} can use these symbolic names like
 5712: @c all others.  In this case, the use of the literal string tokens in
 5713: @c the grammar file has no effect on @code{yylex}.
 5714: @c
 5715: 文法が文字列リテラルトークンに対する別名として記号トークン名を
 5716: 定義しているならば、@code{yylex}はその記号名を他のトークンの記号名と
 5717: 同様に使えます。この場合、文法ファイルの中での文字列リテラルトークンの
 5718: 利用は、@code{yylex}にまったく影響しません。
 5719: 
 5720: @item
 5721: @c @code{yylex} can find the multi-character token in the @code{yytname}
 5722: @c table.  The index of the token in the table is the token type's code.
 5723: @c The name of a multi-character token is recorded in @code{yytname} with a
 5724: @c double-quote, the token's characters, and another double-quote.  The
 5725: @c token's characters are not escaped in any way; they appear verbatim in
 5726: @c the contents of the string in the table.
 5727: @c
 5728: @code{yylex}は、@code{yytname}表の中で、
 5729: 複数文字トークンを見つけられます。
 5730: トークンに対する表の添え字は、そのトークン型の番号です。
 5731: 複数文字トークンは@code{yytname}の中にダブルクォート記号で囲まれて
 5732: 記憶されます。
 5733: トークンに含まれる文字はエスケープされず、
 5734: 表の中の文字列にそのまま書き込まれています。
 5735: 
 5736: @c Here's code for looking up a token in @code{yytname}, assuming that the
 5737: @c characters of the token are stored in @code{token_buffer}.
 5738: 
 5739: トークンを構成する文字列が@code{token_buffer}に記憶されていると仮定して、
 5740: @code{yytname}からトークンを探し出すプログラムを示します。
 5741: 
 5742: @smallexample
 5743: for (i = 0; i < YYNTOKENS; i++)
 5744:   @{
 5745:     if (yytname[i] != 0
 5746:         && yytname[i][0] == '"'
 5747:         && strncmp (yytname[i] + 1, token_buffer, strlen (token_buffer))
 5748:         && yytname[i][strlen (token_buffer) + 1] == '"'
 5749:         && yytname[i][strlen (token_buffer) + 2] == 0)
 5750:       break;
 5751:   @}
 5752: @end smallexample
 5753: 
 5754: @c The @code{yytname} table is generated only if you use the
 5755: @c @code{%token_table} declaration.  @xref{Decl Summary}.
 5756: 
 5757: @code{yytname}表は、@code{%token_table}宣言をした場合にのみ生成されます。
 5758: @xref{Decl Summary}。
 5759: 
 5760: @end itemize
 5761: 
 5762: 
 5763: @c =====================================================================
 5764: @node Token Values, Token Positions, Calling Convention, Lexical
 5765: @c @subsection Semantic Values of Tokens
 5766: @subsection トークンの意味値
 5767: 
 5768: @vindex yylval
 5769: @c In an ordinary (nonreentrant) parser, the semantic value of the token must
 5770: @c be stored into the global variable @code{yylval}.  When you are using
 5771: @c just one data type for semantic values, @code{yylval} has that type.
 5772: @c Thus, if the type is @code{int} (the default), you might write this in
 5773: @c @code{yylex}:
 5774: 
 5775: 通常の再入可能でない構文解析器では、
 5776: トークンの意味値が広域変数@code{yylval}に代入される必要があります。
 5777: 意味値に対してただ1つのデータ型を使っている場合には、
 5778: @code{yylval}の型もそうです。
 5779: したがって、たとえば、宣言を省略して型が@code{int}ならば、
 5780: 次のように書けます。
 5781: 
 5782: @example
 5783: @group
 5784:   @dots{}
 5785: @c   yylval = value;  /* Put value onto Bison stack. */
 5786:   yylval = value;  /* 値をBisonスタックに積む。 */
 5787: @c   return INT;      /* Return the type of the token. */
 5788:   return INT;      /* トークン型を返す。 */
 5789:   @dots{}
 5790: @end group
 5791: @end example
 5792: 
 5793: @c When you are using multiple data types, @code{yylval}'s type is a union
 5794: @c made from the @code{%union} declaration
 5795: @c (@pxref{Union Decl, ,The Collection of Value Types}).  So when
 5796: @c you store a token's value, you must use the proper member of the union.
 5797: @c If the @code{%union} declaration looks like this:
 5798: 
 5799: 複数のデータ型を使っている場合には、
 5800: @code{%union}宣言で作られた共用体が@code{yylval}の型になります
 5801: (@pxref{Union Decl, ,The Collection of Value Types})。
 5802: そこで、トークンの値を代入するには、
 5803: 共用体のメンバの名前を指定する必要があります。
 5804: @code{%union}宣言の例を示します。
 5805: 
 5806: @example
 5807: @group
 5808: %union @{
 5809:   int intval;
 5810:   double val;
 5811:   symrec *tptr;
 5812: @}
 5813: @end group
 5814: @end example
 5815: 
 5816: @c @noindent
 5817: @c then the code in @code{yylex} might look like this:
 5818: 
 5819: すると、@code{yylex}の中のプログラムは次のようになります。
 5820: 
 5821: @example
 5822: @group
 5823:   @dots{}
 5824: @c   yylval.intval = value; /* Put value onto Bison stack. */
 5825:   yylval.intval = value; /* 値をBisonスタックに積む。 */
 5826: @c   return INT;          /* Return the type of the token. */
 5827:   return INT;          /* トークン型を返す。 */
 5828:   @dots{}
 5829: @end group
 5830: @end example
 5831: 
 5832: 
 5833: @c =====================================================================
 5834: @node Token Positions, Pure Calling, Token Values, Lexical
 5835: @c @subsection Textual Positions of Tokens
 5836: @subsection トークンのテキスト中の位置
 5837: 
 5838: @vindex yylloc
 5839: @c If you are using the @samp{@@@var{n}}-feature
 5840: @c (@pxref{Action Features, ,Special Features for Use in Actions}) in
 5841: @c actions to keep track of the textual locations of tokens and groupings,
 5842: @c then you must provide this information in @code{yylex}.  The function
 5843: @c @code{yyparse} expects to find the textual location of a token just parsed
 5844: @c in the global variable @code{yylloc}.  So @code{yylex} must store the
 5845: @c proper data in that variable.  The value of @code{yylloc} is a structure
 5846: @c and you need only initialize the members that are going to be used by the
 5847: @c actions.  The four members are called @code{first_line},
 5848: @c @code{first_column}, @code{last_line} and @code{last_column}.  Note that
 5849: @c the use of this feature makes the parser noticeably slower.
 5850: 
 5851: アクションの中で@samp{@@@var{n}}機能
 5852: (@pxref{Action Features, ,Special Features for Use in Actions})を
 5853: 使っている場合には、トークンとグループのテキスト中の位置を
 5854: 見失わないように、@code{yylex}の中で位置情報を提供する必要があります。
 5855: 関数@code{yyparse}は、ちょうど解析されたトークンのテキスト中の位置が、
 5856: 広域変数@code{yylloc}に記憶されていると仮定します。
 5857: そこで、@code{yylex}は、@code{yyloc}に正しいデータを記憶する必要があります。
 5858: 変数@code{yylloc}は構造体で、アクションの中で使われる場合にのみ、
 5859: メンバを初期化する必要があります。
 5860: メンバは、@code{first_line}、@code{first_column}、
 5861: @code{last_line}、@code{last_column}の4つです。
 5862: この機能を使うと、構文解析器が著しく遅くなることに注意してください。
 5863: 
 5864: @tindex YYLTYPE
 5865: @c The data type of @code{yylloc} has the name @code{YYLTYPE}.
 5866: 
 5867: @code{yylloc}のデータ型は、@code{YYLTYPE}という名前を持っています。
 5868: 
 5869: 
 5870: @c =====================================================================
 5871: @node Pure Calling,  , Token Positions, Lexical
 5872: @c @subsection Calling Conventions for Pure Parsers
 5873: @subsection 再入可能構文解析器を呼び出す方法
 5874: 
 5875: @c When you use the Bison declaration @code{%pure_parser} to request a
 5876: @c pure, reentrant parser, the global communication variables @code{yylval}
 5877: @c and @code{yylloc} cannot be used.  (@xref{Pure Decl, ,A Pure (Reentrant)
 5878: @c Parser}.)  In such parsers the two global variables are replaced by
 5879: @c pointers passed as arguments to @code{yylex}.  You must declare them as
 5880: @c shown here, and pass the information back by storing it through those
 5881: @c pointers.
 5882: 
 5883: 純粋な、つまり再入可能な、構文解析器を生成するために、
 5884: @code{%pure_parser}をBison宣言すると、広域変数@code{yylval}と
 5885: @code{yylloc}を使えなくなります
 5886: (@pxref{Pure Decl, ,A Pure (Reentrant) Parser})。
 5887: このような構文解析器では、2つの広域変数の代わりに、
 5888: @code{yylex}への引数として渡されるポインタを使います。
 5889: @code{yylex}を次のように宣言し、
 5890: これらのポインタを通して情報を受け渡しする必要があります。
 5891: 
 5892: @example
 5893: yylex (lvalp, llocp)
 5894:      YYSTYPE *lvalp;
 5895:      YYLTYPE *llocp;
 5896: @{
 5897:   @dots{}
 5898: @c   *lvalp = value;  /* Put value onto Bison stack.  */
 5899:   *lvalp = value;  /* 値をBisonスタックに積む。  */
 5900: @c   return INT;      /* Return the type of the token.  */
 5901:   return INT;      /* トークン型を返す。 */
 5902:   @dots{}
 5903: @}
 5904: @end example
 5905: 
 5906: @c If the grammar file does not use the @samp{@@} constructs to refer to
 5907: @c textual positions, then the type @code{YYLTYPE} will not be defined.  In
 5908: @c this case, omit the second argument; @code{yylex} will be called with
 5909: @c only one argument.
 5910: 
 5911: 文法ファイルがテキスト中の位置を参照するための@samp{@@}機能を
 5912: 使っていない場合は、@code{YYLTYPE}は定義されません。
 5913: この場合、第2引数を省略し、@code{yylex}は
 5914: 1個の引数をともなって呼び出されます。
 5915: 
 5916: @vindex YYPARSE_PARAM
 5917: @c If you use a reentrant parser, you can optionally pass additional
 5918: @c parameter information to it in a reentrant way.  To do so, define the
 5919: @c macro @code{YYPARSE_PARAM} as a variable name.  This modifies the
 5920: @c @code{yyparse} function to accept one argument, of type @code{void *},
 5921: @c with that name.
 5922: 
 5923: 再入可能な構文解析器を使っている場合、
 5924: 再入可能な方法で構文解析器に追加の引数を渡す方法があります。
 5925: そのためには、マクロ@code{YYPARSE_PARAM}を変数名として定義します。
 5926: すると、関数@code{yyparse}は、定義された名前で、型が@code{void *}の
 5927: 追加の引数を受け取ります。
 5928: 
 5929: @c When you call @code{yyparse}, pass the address of an object, casting the
 5930: @c address to @code{void *}.  The grammar actions can refer to the contents
 5931: @c of the object by casting the pointer value back to its proper type and
 5932: @c then dereferencing it.  Here's an example.  Write this in the parser:
 5933: 
 5934: @code{yyparse}を呼び出すときに、オブジェクトの番地を
 5935: @code{void *}型にキャストして渡します。
 5936: 文法のアクションは、ポインタを適切な型へのポインタへキャストし、
 5937: 逆参照して、オブジェクトの内容を参照できます。
 5938: 例を示します。
 5939: 
 5940: @example
 5941: %@{
 5942: struct parser_control
 5943: @{
 5944:   int nastiness;
 5945:   int randomness;
 5946: @};
 5947: 
 5948: #define YYPARSE_PARAM parm
 5949: %@}
 5950: @end example
 5951: 
 5952: @c @noindent
 5953: @c Then call the parser like this:
 5954: 次のように構文解析器を呼び出します。
 5955: 
 5956: @example
 5957: struct parser_control
 5958: @{
 5959:   int nastiness;
 5960:   int randomness;
 5961: @};
 5962: 
 5963: @dots{}
 5964: 
 5965: @{
 5966:   struct parser_control foo;
 5967: @c  @dots{}  /* @r{Store proper data in @code{foo}.}  */
 5968:   @dots{}  /* @r{@code{foo}に正しいデータを記憶}  */
 5969:   value = yyparse ((void *) &foo);
 5970:   @dots{}
 5971: @}
 5972: @end example
 5973: 
 5974: @c @noindent
 5975: @c In the grammar actions, use expressions like this to refer to the data:
 5976: 
 5977: 文法アクションの中では、データを参照するために次のような式を使います。
 5978: 
 5979: @example
 5980: ((struct parser_control *) parm)->randomness
 5981: @end example
 5982: 
 5983: @vindex YYLEX_PARAM
 5984: @c If you wish to pass the additional parameter data to @code{yylex},
 5985: @c define the macro @code{YYLEX_PARAM} just like @code{YYPARSE_PARAM}, as
 5986: @c shown here:
 5987: 
 5988: @code{yylex}に追加の引数を渡したい場合には、
 5989: @code{YYPARSE_PARAM}と同様に、マクロ@code{YYLEX_PARAM}を定義します。
 5990: 例を示します。
 5991: 
 5992: @example
 5993: %@{
 5994: struct parser_control
 5995: @{
 5996:   int nastiness;
 5997:   int randomness;
 5998: @};
 5999: 
 6000: #define YYPARSE_PARAM parm
 6001: #define YYLEX_PARAM parm
 6002: %@}
 6003: @end example
 6004: 
 6005: @c You should then define @code{yylex} to accept one additional
 6006: @c argument---the value of @code{parm}.  (This makes either two or three
 6007: @c arguments in total, depending on whether an argument of type
 6008: @c @code{YYLTYPE} is passed.)  You can declare the argument as a pointer to
 6009: @c the proper object type, or you can declare it as @code{void *} and
 6010: @c access the contents as shown above.
 6011: 
 6012: そして、@code{yylex}が追加の引数、@code{parm}の値を受け取るように、
 6013: @code{yylex}を定義する必要があります
 6014: (型@code{YYLTYPE}のどの引数が渡されるかに応じて、
 6015: 引数の合計が2個または3個になります)。
 6016: 引数を正しいオブジェクト型として宣言できます。すなわち@code{void *}として
 6017: 宣言し、上記の番地を参照できます。
 6018: 
 6019: @c You can use @samp{%pure_parser} to request a reentrant parser without
 6020: @c also using @code{YYPARSE_PARAM}.  Then you should call @code{yyparse}
 6021: @c with no arguments, as usual.
 6022: 
 6023: @code{YYPARSE_PARAM}を使わずに、@samp{%pure_parser}を使って、
 6024: 再入可能な構文解析器を生成することも可能です。
 6025: その場合、引数をつけずに@code{yyparse}を呼び出すべきです。
 6026: 
 6027: 
 6028: @c =====================================================================
 6029: @node Error Reporting, Action Features, Lexical, Interface
 6030: @c @section The Error Reporting Function @code{yyerror}
 6031: @section エラー報告関数@code{yyerror}
 6032: @cindex error reporting function
 6033: @findex yyerror
 6034: @cindex parse error
 6035: @cindex syntax error
 6036: @cindex エラー報告関数
 6037: @cindex 構文解析エラー
 6038: @cindex 文法エラー
 6039: 
 6040: @c The Bison parser detects a @dfn{parse error} or @dfn{syntax error}
 6041: @c whenever it reads a token which cannot satisfy any syntax rule.  A
 6042: @c action in the grammar can also explicitly proclaim an error, using the
 6043: @c macro @code{YYERROR}
 6044: @c (@pxref{Action Features, ,Special Features for Use in Actions}).
 6045: 
 6046: Bison構文解析器は、文法規則に適合しないトークンを読むたびに、
 6047: @dfn{構文解析エラー(parse error)}すなわち@dfn{文法エラー(syntax error)}を
 6048: 検出します。文法中のアクションは、マクロ@code{YYERROR}を使って、
 6049: 明示的にエラーを示せます
 6050: (@pxref{Action Features, ,Special Features for Use in Actions})。
 6051: 
 6052: @c The Bison parser expects to report the error by calling an error
 6053: @c reporting function named @code{yyerror}, which you must supply.  It is
 6054: @c called by @code{yyparse} whenever a syntax error is found, and it
 6055: @c receives one argument.  For a parse error, the string is normally
 6056: @c @w{@code{"parse error"}}.
 6057: 
 6058: Bison構文解析器は、@code{yyerror}という名前の関数を使って、
 6059: エラーを報告するようになっています。
 6060: 事前に用意が必要な
 6061: この関数は、文法エラーが発生するたびに、1個の引数をともなって、
 6062: @code{yyparse}から呼び出されます。
 6063: 構文解析エラーに対して、引数の文字列は通常@w{@code{"parse error"}}です。
 6064: 
 6065: @findex YYERROR_VERBOSE
 6066: @c If you define the macro @code{YYERROR_VERBOSE} in the Bison declarations
 6067: @c section (@pxref{Bison Declarations, ,The Bison Declarations Section}),
 6068: @c then Bison provides a more verbose
 6069: @c and specific error message string instead of just plain @w{@code{"parse
 6070: @c error"}}.  It doesn't matter what definition you use for
 6071: @c @code{YYERROR_VERBOSE}, just whether you define it.
 6072: 
 6073: Bison定義部(@pxref{Bison Declarations, ,The Bison Declarations Section})で、
 6074: マクロ@code{YYERROR_VERBOSE}を定義すると、
 6075: @w{@code{"parse error"}}の代わりに、
 6076: エラーを詳細に報告する文字列が用意されます。
 6077: マクロ@code{YYERROR_VERBOSE}の定義はなんでもかまいません。
 6078: 
 6079: @c The parser can detect one other kind of error: stack overflow.  This
 6080: @c happens when the input contains constructions that are very deeply
 6081: @c nested.  It isn't likely you will encounter this, since the Bison
 6082: @c parser extends its stack automatically up to a very large limit.  But
 6083: @c if overflow happens, @code{yyparse} calls @code{yyerror} in the usual
 6084: @c fashion, except that the argument string is @w{@code{"parser stack
 6085: @c overflow"}}.
 6086: 
 6087: 構文解析器は、もう1種類のエラーであるスタックオーバーフローを検出する
 6088: 可能性があります。これは、入力がきわめて深い入れ子からなっていると
 6089: 起こることがあります。Bison構文解析器は自動的にスタックの限界を大きく拡張し
 6090: ているので、スタックオーバーフローはめったに起きません。
 6091: しかし、もしスタックオーバーフローが起きれば、
 6092: @w{@code{"parser stack overflow"}}という
 6093: 文字列の引数をともなって、@code{yyerror}が呼び出されます。
 6094: 
 6095: @c The following definition suffices in simple programs:
 6096: 
 6097: 単純なプログラムでは、次の例のように@code{yyerror}を定義できます。
 6098: 
 6099: @example
 6100: @group
 6101: yyerror (s)
 6102:      char *s;
 6103: @{
 6104: @end group
 6105: @group
 6106:   fprintf (stderr, "%s\n", s);
 6107: @}
 6108: @end group
 6109: @end example
 6110: 
 6111: @c After @code{yyerror} returns to @code{yyparse}, the latter will attempt
 6112: @c error recovery if you have written suitable error recovery grammar rules
 6113: @c (@pxref{Error Recovery}).  If recovery is impossible, @code{yyparse} will
 6114: @c immediately return 1.
 6115: 
 6116: @code{yyerror}から戻った後、@code{yyparse}は、
 6117: 適切なエラー回復文法規則(@pxref{Error Recovery})があれば、
 6118: エラーからの回復を試みます。
 6119: もし、回復が不可能ならば、@code{yyparse}は即座に1を返します。
 6120: 
 6121: @vindex yynerrs
 6122: @c The variable @code{yynerrs} contains the number of syntax errors
 6123: @c encountered so far.  Normally this variable is global; but if you
 6124: @c request a pure parser
 6125: @c (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}) then it is a local variable
 6126: @c which only the actions can access.
 6127: 
 6128: 変数@code{yynerrs}には、それまでに出くわした文法エラーの数が記憶されています。
 6129: 通常、この変数は広域変数です。
 6130: しかし、再入可能な構文解析器(@pxref{Pure Decl, ,A Pure (Reentrant) Parser})
 6131: を生成した場合には、アクションからのみ参照可能な局所変数になります。
 6132: 
 6133: 
 6134: @c =====================================================================
 6135: @node Action Features,  , Error Reporting, Interface
 6136: @c @section Special Features for Use in Actions
 6137: @section アクション中で使える特別な機能
 6138: @cindex summary, action features
 6139: @cindex action fetures summary
 6140: @cindex 要約, アクション
 6141: @cindex アクションの要約
 6142:  
 6143: @c Here is a table of Bison constructs, variables and macros that
 6144: @c are useful in actions.
 6145: 
 6146: ここの表では、アクション中で有用な、Bisonの構造物、変数、
 6147: マクロを示します。
 6148: 
 6149: @table @samp
 6150: @item $$
 6151: @c Acts like a variable that contains the semantic value for the
 6152: @c grouping made by the current rule.  @xref{Actions}.
 6153: @c
 6154: 現在の規則で作られるグループに対する意味値を保持する変数のように働きます。
 6155: @xref{Actions}。
 6156: 
 6157: @item $@var{n}
 6158: @c Acts like a variable that contains the semantic value for the
 6159: @c @var{n}th component of the current rule.  @xref{Actions}.
 6160: @c
 6161: 現在の規則の@var{n}番目の構成要素に対する意味値を保持する変数のように
 6162: 働きます。@xref{Actions}。
 6163: 
 6164: @item $<@var{typealt}>$
 6165: @c Like @code{$$} but specifies alternative @var{typealt} in the union
 6166: @c specified by the @code{%union} declaration.
 6167: @c @xref{Action Types, ,Data Types of Values in Actions}.
 6168: @c
 6169: @code{$$}に似ていますが、@code{%union}宣言で指定された共用体の中の
 6170: @var{typealt}を選びます。
 6171: @xref{Action Types, ,Data Types of Values in Actions}。
 6172: 
 6173: @item $<@var{typealt}>@var{n}
 6174: @c Like @code{$@var{n}} but specifies alternative @var{typealt} in the
 6175: @c union specified by the @code{%union} declaration.  
 6176: @c @xref{Action Types, ,Data Types of Values in Actions}.@refill
 6177: @c
 6178: @code{$@var{n}}に似ていますが、@code{%union}宣言で指定された共用体の中の
 6179: @var{typealt}を選びます。
 6180: @xref{Action Types, ,Data Types of Values in Actions}。
 6181: 
 6182: @item YYABORT;
 6183: @c Return immediately from @code{yyparse}, indicating failure.
 6184: @c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
 6185: @c
 6186: @code{yyparse}からただちに戻り、失敗を示します。
 6187: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 6188: 
 6189: @item YYACCEPT;
 6190: @c Return immediately from @code{yyparse}, indicating success.
 6191: @c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
 6192: @c
 6193: @code{yyparse}からただちに戻り、成功を示します。
 6194: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 6195: 
 6196: @item YYBACKUP (@var{token}, @var{value});
 6197: @findex YYBACKUP
 6198: @c Unshift a token.  This macro is allowed only for rules that reduce
 6199: @c a single value, and only when there is no look-ahead token.
 6200: @c It installs a look-ahead token with token type @var{token} and
 6201: @c semantic value @var{value}; then it discards the value that was
 6202: @c going to be reduced by this rule.
 6203: @c
 6204: トークンを逆シフトします。
 6205: 1個の値を還元する規則の中で、先読みトークンがない場合にのみ、
 6206: このマクロが使えます。
 6207: このマクロは、トークン型が@var{token}で意味値が@var{value}のトークンを、
 6208: 先読みトークンとして格納し、この規則で還元されるはずだった値を捨てます。
 6209: 
 6210: @c If the macro is used when it is not valid, such as when there is
 6211: @c a look-ahead token already, then it reports a syntax error with
 6212: @c a message @samp{cannot back up} and performs ordinary error
 6213: @c recovery.
 6214: 
 6215: 先読みトークンがすでにあるような、このマクロが無効な状況で
 6216: このマクロを使うと、メッセージ@samp{cannnot back up}をともなう
 6217: 文法エラーが報告され、通常のエラー回復が行われます。
 6218: 
 6219: @c In either case, the rest of the action is not executed.
 6220: 
 6221: どちらの場合も、アクションの残りの部分は実行されません。
 6222: 
 6223: @item YYEMPTY
 6224: @vindex YYEMPTY
 6225: @c Value stored in @code{yychar} when there is no look-ahead token.
 6226: @c
 6227: 先読みトークンがない場合に、変数@code{yychar}に記憶されている値です。
 6228: 
 6229: @item YYERROR;
 6230: @findex YYERROR
 6231: @c Cause an immediate syntax error.  This statement initiates error
 6232: @c recovery just as if the parser itself had detected an error; however, it
 6233: @c does not call @code{yyerror}, and does not print any message.  If you
 6234: @c want to print an error message, call @code{yyerror} explicitly before
 6235: @c the @samp{YYERROR;} statement.  @xref{Error Recovery}.
 6236: @c
 6237: ただちに文法エラーを発生させます。この文は、構文解析器がエラーを検出したように
 6238: エラー回復を始めますが、@code{yyerror}を呼び出さず、
 6239: メッセージは表示されません。
 6240: もし、エラーメッセージを表示したければ、@samp{YYERROR}文よりも先に、
 6241: 明示的に@code{yyerror}を呼び出してください。
 6242: @xref{Error Recovery}。
 6243: 
 6244: @item YYRECOVERING
 6245: @c This macro stands for an expression that has the value 1 when the parser
 6246: @c is recovering from a syntax error, and 0 the rest of the time.
 6247: @c @xref{Error Recovery}.
 6248: @c
 6249: このマクロの値は、字句解析器が文法エラーからの回復中ならば1、
 6250: そうでなければ0です。
 6251: @xref{Error Recovery}。
 6252: 
 6253: @item yychar
 6254: @c Variable containing the current look-ahead token.  (In a pure parser,
 6255: @c this is actually a local variable within @code{yyparse}.)  When there is
 6256: @c no look-ahead token, the value @code{YYEMPTY} is stored in the variable.
 6257: @c @xref{Look-Ahead, ,Look-Ahead Tokens}.
 6258: @c
 6259: 現在の先読みトークンを含んでいる変数です
 6260: (再入可能構文解析器では、@code{yyparse}の局所変数です)。
 6261: 先読みトークンがない場合には、この変数に
 6262: @code{YYEMPTY}という値が入っています。
 6263: @xref{Look-Ahead, ,Look-Ahead Tokens}。
 6264: 
 6265: @item yyclearin;
 6266: @c Discard the current look-ahead token.  This is useful primarily in
 6267: @c error rules.  @xref{Error Recovery}.
 6268: @c
 6269: 現在の先読みトークンを捨てます。エラー規則の中で有用です。
 6270: @xref{Error Recovery}。
 6271: 
 6272: @item yyerrok;
 6273: @c Resume generating error messages immediately for subsequent syntax
 6274: @c errors.  This is useful primarily in error rules.  
 6275: @c @xref{Error Recovery}.
 6276: @c
 6277: 後に続く文法エラーに対して、エラーメッセージの生成を再開します。
 6278: これは、エラー規則で特に重要です。
 6279: @xref{Error Recovery}。
 6280: 
 6281: @item @@@var{n}
 6282: @findex @@@var{n}
 6283: @c Acts like a structure variable containing information on the line
 6284: @c numbers and column numbers of the @var{n}th component of the current
 6285: @c rule.  The structure has four members, like this:
 6286: @c
 6287: 現在の規則の第@var{n}要素の、行番号と列番号を含む、
 6288: 配列変数のように働きます。
 6289: 次のようなメンバがあります。
 6290: 
 6291: @example
 6292: struct @{
 6293:   int first_line, last_line;
 6294:   int first_column, last_column;
 6295: @};
 6296: @end example
 6297: 
 6298: @c Thus, to get the starting line number of the third component, use
 6299: @c @samp{@@3.first_line}.
 6300: 
 6301: たとえば、第3要素の開始行番号を知るには、
 6302: @samp{@@3.first_line}とします。
 6303: 
 6304: @c In order for the members of this structure to contain valid information,
 6305: @c you must make @code{yylex} supply this information about each token.
 6306: @c If you need only certain members, then @code{yylex} need only fill in
 6307: @c those members.
 6308: 
 6309: この構造体のメンバを有効な情報にするためには、
 6310: @code{yylex}がそれぞれのトークンに対して、
 6311: 情報を提供する必要があります。
 6312: 一部分のメンバだけが必要ならば、
 6313: @code{yylex}はそのメンバの値を設定するだけでかまいません。
 6314: @footnote{【訳注】@code{yylex}は、変数@code{yylloc}に、
 6315: トークンの位置情報を代入します。}
 6316: 
 6317: @c The use of this feature makes the parser noticeably slower.
 6318: 
 6319: この機能を使うと、字句解析器が著しく遅くなります。
 6320: @end table
 6321: 
 6322: 
 6323: @c =====================================================================
 6324: @node Algorithm, Error Recovery, Interface, Top
 6325: @c @chapter The Bison Parser Algorithm 
 6326: @chapter Bison構文解析器のアルゴリズム
 6327: @cindex Bison parser algorithm 
 6328: @cindex algorithm of parser
 6329: @cindex shifting
 6330: @cindex reduction
 6331: @cindex parser stack
 6332: @cindex stack, parser
 6333: @cindex Bison構文解析器のアルゴリズム
 6334: @cindex シフト
 6335: @cindex 還元
 6336: @cindex 構文解析器のスタック
 6337: @cindex スタック, 構文解析器
 6338: 
 6339: @c As Bison reads tokens, it pushes them onto a stack along with their
 6340: @c semantic values.  The stack is called the @dfn{parser stack}.  Pushing a
 6341: @c token is traditionally called @dfn{shifting}.
 6342: 
 6343: Bison構文解析器は、トークンを読むと、トークンの意味値とともにスタックに積みます。
 6344: このスタックを@dfn{構文解析器スタック(parser stack)}と呼びます。
 6345: トークンをスタックに積むことを、伝統的に
 6346: @dfn{シフト(shifting)}と呼びます。
 6347: 
 6348: @c For example, suppose the infix calculator has read @samp{1 + 5 *}, with a
 6349: @c @samp{3} to come.  The stack will have four elements, one for each token
 6350: @c that was shifted.
 6351: 
 6352: たとえば、中間記法電卓が、@samp{1 + 5 *}をすでに読んでいて、
 6353: @samp{3}を受け取ったと仮定します。
 6354: スタックには4個の要素があり、トークンそれぞれがシフトされています。
 6355: 
 6356: @c But the stack does not always have an element for each token read.  When
 6357: @c the last @var{n} tokens and groupings shifted match the components of a
 6358: @c grammar rule, they can be combined according to that rule.  This is called
 6359: @c @dfn{reduction}.  Those tokens and groupings are replaced on the stack by a
 6360: @c single grouping whose symbol is the result (left hand side) of that rule.
 6361: @c Running the rule's action is part of the process of reduction, because this
 6362: @c is what computes the semantic value of the resulting grouping.
 6363: 
 6364: しかし、スタックに常に読み込まれたトークンそれぞれに対する
 6365: 要素があるわけではありません。
 6366: 最後の@var{n}個のトークンとグループが文法規則に当てはまる場合には、
 6367: それらは規則に従って組み合わされます。
 6368: これを、@dfn{還元(reduction)}と呼びます。
 6369: スタックにあったトークンとグループは、
 6370: 規則の結果、つまり左側にある記号である、1個のグループに置き換えられます。
 6371: 規則のアクションの実行は、結果のグループの意味値を計算するので、
 6372: 還元の手順の1つです。
 6373: 
 6374: @c For example, if the infix calculator's parser stack contains this:
 6375: 
 6376: たとえば、中間記法電卓の構文解析器スタックの内容は次のようになります。
 6377: 
 6378: @example
 6379: 1 + 5 * 3
 6380: @end example
 6381: 
 6382: @c @noindent
 6383: @c and the next input token is a newline character, then the last three
 6384: @c elements can be reduced to 15 via the rule:
 6385: 
 6386: そして、入力された次のトークンが改行符号ならば、
 6387: 次の規則に従って、最後の3個の要素が15に還元されます。
 6388: 
 6389: @example
 6390: expr: expr '*' expr;
 6391: @end example
 6392: 
 6393: @c @noindent
 6394: @c Then the stack contains just these three elements:
 6395: 
 6396: そして、スタックは3個の要素を持ちます。
 6397: 
 6398: @example
 6399: 1 + 15
 6400: @end example
 6401: 
 6402: @c @noindent
 6403: @c At this point, another reduction can be made, resulting in the single value
 6404: @c 16.  Then the newline token can be shifted.
 6405: 
 6406: この時点で、別の還元が可能になり、1個の値16を得ます。
 6407: そして、改行符号がシフトされます。
 6408: 
 6409: @c The parser tries, by shifts and reductions, to reduce the entire input down
 6410: @c to a single grouping whose symbol is the grammar's start-symbol
 6411: @c (@pxref{Language and Grammar, ,Languages and Context-Free Grammars}).
 6412: 
 6413: 構文解析器は、シフトと還元によって、入力全体を
 6414: 文法の開始記号である1個のグループに還元しようとします
 6415: (@pxref{Language and Grammar, ,Languages and Context-Free Grammars})。
 6416: 
 6417: @c This kind of parser is known in the literature as a bottom-up parser.
 6418: 
 6419: この種類の構文解析器は、ボトムアップ構文解析器として知られています。
 6420: 
 6421: @menu
 6422: * Look-Ahead::        Parser looks one token ahead when deciding what to do.
 6423: * Shift/Reduce::      Conflicts: when either shifting or reduction is valid.
 6424: * Precedence::        Operator precedence works by resolving conflicts.
 6425: * Contextual Precedence::  When an operator's precedence depends on context.
 6426: * Parser States::     The parser is a finite-state-machine with stack.
 6427: * Reduce/Reduce::     When two rules are applicable in the same situation.
 6428: * Mystery Conflicts::  Reduce/reduce conflicts that look unjustified.
 6429: * Stack Overflow::    What happens when stack gets full.  How to avoid it.
 6430: @end menu
 6431: 
 6432: 
 6433: @c =====================================================================
 6434: @node Look-Ahead, Shift/Reduce,  , Algorithm
 6435: @c @section Look-Ahead Tokens
 6436: @section 先読みトークン
 6437: @cindex look-ahead token
 6438: @cindex 先読みトークン
 6439: 
 6440: @c The Bison parser does @emph{not} always reduce immediately as soon as the
 6441: @c last @var{n} tokens and groupings match a rule.  This is because such a
 6442: @c simple strategy is inadequate to handle most languages.  Instead, when a
 6443: @c reduction is possible, the parser sometimes ``looks ahead'' at the next
 6444: @c token in order to decide what to do.
 6445: 
 6446: Bison構文解析器は、必ずしも文法規則に適合する最後の@var{n}個のトークン
 6447: またはグループが見つかるとすぐに還元を行う@emph{わけではありません}。
 6448: そのような単純な方法は、多くの言語の処理に適さないからです。
 6449: その代わりに、還元が可能な場合に、構文解析器は次のトークンを
 6450: 「先読み」し、次に何をするべきかを決定します。
 6451: 
 6452: @c When a token is read, it is not immediately shifted; first it becomes the
 6453: @c @dfn{look-ahead token}, which is not on the stack.  Now the parser can
 6454: @c perform one or more reductions of tokens and groupings on the stack, while
 6455: @c the look-ahead token remains off to the side.  When no more reductions
 6456: @c should take place, the look-ahead token is shifted onto the stack.  This
 6457: @c does not mean that all possible reductions have been done; depending on the
 6458: @c token type of the look-ahead token, some rules may choose to delay their
 6459: @c application.
 6460: 
 6461: トークンが読まれると、それはすぐにシフトされるのではなく、
 6462: まず、@dfn{先読みトークン(look-ahead token)}になり、
 6463: スタックには置かれません。
 6464: 先読みトークンを残したまま、構文解析器が、スタック上のトークンまたは
 6465: グループに対して1個以上の還元を実行します。
 6466: それ以上の還元が起こりえない場合に、
 6467: 先読みトークンはスタックにシフトされます。
 6468: これは、すべての可能な還元が実行されたことを意味しません。
 6469: 先読みトークンのトークン型に応じて、
 6470: いくつかの規則は適用を遅らされているかもしれません。
 6471: 
 6472: @c Here is a simple case where look-ahead is needed.  These three rules define
 6473: @c expressions which contain binary addition operators and postfix unary
 6474: @c factorial operators (@samp{!}), and allow parentheses for grouping.
 6475: 
 6476: 先読みが必要な簡単な例を示します。
 6477: 下記の3個の規則は、2項加算演算子、単項階乗演算子(@samp{!})、
 6478: グループのためのかっこを含みます。
 6479: 
 6480: @example
 6481: @group
 6482: expr:     term '+' expr
 6483:         | term
 6484:         ;
 6485: @end group
 6486: 
 6487: @group
 6488: term:     '(' expr ')'
 6489:         | term '!'
 6490:         | NUMBER
 6491:         ;
 6492: @end group
 6493: @end example
 6494: 
 6495: @c Suppose that the tokens @w{@samp{1 + 2}} have been read and shifted; what
 6496: @c should be done?  If the following token is @samp{)}, then the first three
 6497: @c tokens must be reduced to form an @code{expr}.  This is the only valid
 6498: @c course, because shifting the @samp{)} would produce a sequence of symbols
 6499: @c @w{@code{term ')'}}, and no rule allows this.
 6500: 
 6501: トークン@w{@samp{1 + 2}}が読み込まれてシフトされているときに、
 6502: 何が起きるでしょうか。もし、続くトークンが@samp{)}ならば、
 6503: 最初の3個のトークンは@code{expr}の形式に還元される必要があります。
 6504: これが、唯一有効な道です。
 6505: なぜならば、@samp{)}をシフトして、@w{@code{term ')'}}という記号列も
 6506: 生成可能ですが、どの規則もそのような記号列を許していないからです。
 6507: 
 6508: @c If the following token is @samp{!}, then it must be shifted immediately so
 6509: @c that @w{@samp{2 !}} can be reduced to make a @code{term}.  If instead the
 6510: @c parser were to reduce before shifting, @w{@samp{1 + 2}} would become an
 6511: @c @code{expr}.  It would then be impossible to shift the @samp{!} because
 6512: @c doing so would produce on the stack the sequence of symbols @code{expr
 6513: @c '!'}.  No rule allows that sequence.
 6514: 
 6515: もし、続くトークンが@samp{!}ならば、それはただちにシフトされる必要があり、
 6516: @w{@samp{2 !}}から@code{term}が還元されます。
 6517: そうではなく、構文解析器がシフトの前に還元していれば、
 6518: @w{@samp{1 + 2}}が@code{expr}に還元されます。
 6519: しかし、そのような還元をしようとすると@code{expr '!'}という記号列を
 6520: スタックに生成しようとするので、@samp{!}をシフトするのは不可能です。
 6521: そのような記号列は許されません。
 6522: 
 6523: @vindex yychar
 6524: @c The current look-ahead token is stored in the variable @code{yychar}.
 6525: @c @xref{Action Features, ,Special Features for Use in Actions}.
 6526: 
 6527: 現在の先読みトークンは、変数@code{yychar}に記憶されています
 6528: @xref{Action Features, ,Special Features for Use in Actions}。
 6529: 
 6530: 
 6531: @c =====================================================================
 6532: @node Shift/Reduce, Precedence, Look-Ahead, Algorithm
 6533: @c @section Shift/Reduce Conflicts
 6534: @section シフト還元衝突
 6535: @cindex conflicts
 6536: @cindex shift/reduce conflicts
 6537: @cindex dangling else
 6538: @cindex else, dangling
 6539: @cindex 衝突
 6540: @cindex シフト還元衝突
 6541: @cindex ぶらさがりelse
 6542: @cindex else, ぶらさがり
 6543: 
 6544: @c Suppose we are parsing a language which has if-then and if-then-else
 6545: @c statements, with a pair of rules like this:
 6546: 
 6547: 次の2個の規則で定められる、``if-then''と``if-then-else''文を持つ
 6548: 言語の構文解析について考えます。
 6549: 
 6550: @example
 6551: @group
 6552: if_stmt:
 6553:           IF expr THEN stmt
 6554:         | IF expr THEN stmt ELSE stmt
 6555:         ;
 6556: @end group
 6557: @end example
 6558: 
 6559: @c @noindent
 6560: @c Here we assume that @code{IF}, @code{THEN} and @code{ELSE} are
 6561: @c terminal symbols for specific keyword tokens.
 6562: 
 6563: ここで、@code{IF}、@code{THEN}、@code{ELSE}は、
 6564: キーワードトークンを表す終端記号であると仮定します。
 6565: 
 6566: @c When the @code{ELSE} token is read and becomes the look-ahead token, the
 6567: @c contents of the stack (assuming the input is valid) are just right for
 6568: @c reduction by the first rule.  But it is also legitimate to shift the
 6569: @c @code{ELSE}, because that would lead to eventual reduction by the second
 6570: @c rule.
 6571: 
 6572: @code{ELSE}トークンが読まれて先読みトークンになったときに、
 6573: 入力が正しいと仮定して、スタックの内容はちょうど
 6574: 最初の規則で還元される右辺になっています。
 6575: しかし、いずれ起こるはずの第2の規則の還元のために、
 6576: @code{ELSE}トークンをシフトすることも有効です。
 6577: 
 6578: @c This situation, where either a shift or a reduction would be valid, is
 6579: @c called a @dfn{shift/reduce conflict}.  Bison is designed to resolve
 6580: @c these conflicts by choosing to shift, unless otherwise directed by
 6581: @c operator precedence declarations.  To see the reason for this, let's
 6582: @c contrast it with the other alternative.
 6583: 
 6584: この、シフトと還元の両方が有効な場合を、
 6585: @dfn{シフト還元衝突(shift/reduce conflict)}と呼びます。
 6586: Bisonは、演算子優先規則宣言で特に指定されていないかぎり、
 6587: シフトを選ぶことで衝突を解決するように設計されています。
 6588: この理由を理解するために、別の選択肢と比較してみましょう。
 6589: 
 6590: @c Since the parser prefers to shift the @code{ELSE}, the result is to attach
 6591: @c the else-clause to the innermost if-statement, making these two inputs
 6592: @c equivalent:
 6593: 
 6594: 構文解析器は@code{ELSE}のシフトを選ぶので、その結果、
 6595: else節はもっとも内側のif文に対応し、次の2つの入力は等価になります。
 6596: 
 6597: @example
 6598: if x then if y then win (); else lose;
 6599: 
 6600: if x then do; if y then win (); else lose; end;
 6601: @end example
 6602: 
 6603: @c But if the parser chose to reduce when possible rather than shift, the
 6604: @c result would be to attach the else-clause to the outermost if-statement,
 6605: @c making these two inputs equivalent:
 6606: 
 6607: しかし、字句解析器がシフトでなく還元を選ぶと、その結果、
 6608: else節がもっとも外側のif文に対応し、次の2つの入力は等価になります。
 6609: 
 6610: @example
 6611: if x then if y then win (); else lose;
 6612: 
 6613: if x then do; if y then win (); end; else lose;
 6614: @end example
 6615: 
 6616: @c The conflict exists because the grammar as written is ambiguous: either
 6617: @c parsing of the simple nested if-statement is legitimate.  The established
 6618: @c convention is that these ambiguities are resolved by attaching the
 6619: @c else-clause to the innermost if-statement; this is what Bison accomplishes
 6620: @c by choosing to shift rather than reduce.  (It would ideally be cleaner to
 6621: @c write an unambiguous grammar, but that is very hard to do in this case.)
 6622: @c This particular ambiguity was first encountered in the specifications of
 6623: @c Algol 60 and is called the ``dangling @code{else}'' ambiguity.
 6624: 
 6625: 文法があいまいに書かれているために、衝突が起きます。
 6626: つまり、入れ子になったif文について、どちらの構文解析結果も正当なのです。
 6627: 確立された習慣では、else節をもっとも内側のif文に対応させて、
 6628: あいまいさを解決しています。
 6629: これが、Bisonが還元よりもシフトを選ぶ理由です
 6630: (理想的には、あいまいでない文法を書くべきですが、この場合には困難です)。
 6631: この問題は、Algol 60の仕様の中に現れたのが最初で、
 6632: 「ぶらさがり@code{else}(dangling @code{else})」問題と呼ばれています。
 6633: 
 6634: @c To avoid warnings from Bison about predictable, legitimate shift/reduce
 6635: @c conflicts, use the @code{%expect @var{n}} declaration.  There will be no
 6636: @c warning as long as the number of shift/reduce conflicts is exactly @var{n}.
 6637: @c @xref{Expect Decl, ,Suppressing Conflict Warnings}.
 6638: 
 6639: 予測可能で正当なシフト還元衝突について、Bisonが警告を表示しないように、
 6640: @code{%expect @var{n}}宣言を使えます。
 6641: すると、ちょうど@var{n}個のシフト還元衝突があるかぎり、
 6642: 警告は表示されません。
 6643: @xref{Expect Decl, ,Suppressing Conflict Warnings}。
 6644: 
 6645: @c The definition of @code{if_stmt} above is solely to blame for the
 6646: @c conflict, but the conflict does not actually appear without additional
 6647: @c rules.  Here is a complete Bison input file that actually manifests the
 6648: @c conflict:
 6649: 
 6650: 上記の@code{if_stmt}の定義は、衝突をわざと発生させるために書きましたが、
 6651: 追加の規則がなければ実際には衝突が起きません。
 6652: 次に、実際に衝突を含む完全なBison入力ファイルの例を示します。
 6653: 
 6654: @example
 6655: @group
 6656: %token IF THEN ELSE variable
 6657: %%
 6658: @end group
 6659: @group
 6660: stmt:     expr
 6661:         | if_stmt
 6662:         ;
 6663: @end group
 6664: 
 6665: @group
 6666: if_stmt:
 6667:           IF expr THEN stmt
 6668:         | IF expr THEN stmt ELSE stmt
 6669:         ;
 6670: @end group
 6671: 
 6672: expr:     variable
 6673:         ;
 6674: @end example
 6675: 
 6676: 
 6677: @c =====================================================================
 6678: @node Precedence, Contextual Precedence, Shift/Reduce, Algorithm
 6679: @c @section Operator Precedence
 6680: @section 演算子の優先順位
 6681: @cindex operator precedence
 6682: @cindex precedence of operators
 6683: @cindex 演算子の優先順位
 6684: @cindex 優先順位, 演算子
 6685: 
 6686: @c Another situation where shift/reduce conflicts appear is in arithmetic
 6687: @c expressions.  Here shifting is not always the preferred resolution; the
 6688: @c Bison declarations for operator precedence allow you to specify when to
 6689: @c shift and when to reduce.
 6690: 
 6691: シフト還元衝突が起きる別の可能性は、算術式の中にあります。
 6692: この場合には、シフトの選択が望ましい解決策であるとは限りません。
 6693: どのような場合にシフトしてどのような場合に還元するべきか指定するために、
 6694: 演算子の優先順位についてのBison宣言を使えます。
 6695: 
 6696: @menu
 6697: * Why Precedence::    An example showing why precedence is needed.
 6698: * Using Precedence::  How to specify precedence in Bison grammars.
 6699: * Precedence Examples::  How these features are used in the previous example.
 6700: * How Precedence::    How they work.
 6701: @end menu
 6702: 
 6703: 
 6704: @c =====================================================================
 6705: @node Why Precedence, Using Precedence,  , Precedence
 6706: @c @subsection When Precedence is Needed
 6707: @subsection 優先順位が必要な場合
 6708: 
 6709: @c Consider the following ambiguous grammar fragment (ambiguous because the
 6710: @c input @w{@samp{1 - 2 * 3}} can be parsed in two different ways):
 6711: 
 6712: 次のあいまいな文法の一部を見てください。
 6713: 入力@w{@samp{1 - 2 * 3}}が2通りに構文解析されうるので、
 6714: この文法はあいまいです。
 6715: 
 6716: @example
 6717: @group
 6718: expr:     expr '-' expr
 6719:         | expr '*' expr
 6720:         | expr '<' expr
 6721:         | '(' expr ')'
 6722:         @dots{}
 6723:         ;
 6724: @end group
 6725: @end example
 6726: 
 6727: @c @noindent
 6728: @c Suppose the parser has seen the tokens @samp{1}, @samp{-} and @samp{2};
 6729: @c should it reduce them via the rule for the addition operator?  It depends
 6730: @c on the next token.  Of course, if the next token is @samp{)}, we must
 6731: @c reduce; shifting is invalid because no single rule can reduce the token
 6732: @c sequence @w{@samp{- 2 )}} or anything starting with that.  But if the next
 6733: @c token is @samp{*} or @samp{<}, we have a choice: either shifting or
 6734: @c reduction would allow the parse to complete, but with different
 6735: @c results.
 6736: 
 6737: 構文解析器が、@samp{1}、@samp{-}、@samp{2}というトークンを
 6738: 読み込んだと仮定します。構文解析器は、減算演算子の規則に従って、
 6739: これらのトークンを還元するべきでしょうか。
 6740: それは、次のトークンに依存します。
 6741: もちろん、次のトークンが@samp{)}ならば、還元する必要があります。
 6742: なぜならば、もしシフトすると、@w{@samp{- 2 )}}またはそれで始まる
 6743: 記号列を還元する必要が生じ、そのような規則はないからです。
 6744: しかし、次のトークンが@samp{*}または@samp{<}ならば、
 6745: シフトと還元のどちらも可能です。
 6746: どちらを選んでも構文解析を完了できますが、解析の結果は異なります。
 6747: 
 6748: @c To decide which one Bison should do, we must consider the
 6749: @c results.  If the next operator token @var{op} is shifted, then it
 6750: @c must be reduced first in order to permit another opportunity to
 6751: @c reduce the sum.  The result is (in effect) @w{@samp{1 - (2
 6752: @c @var{op} 3)}}.  On the other hand, if the subtraction is reduced
 6753: @c before shifting @var{op}, the result is @w{@samp{(1 - 2) @var{op}
 6754: @c 3}}.  Clearly, then, the choice of shift or reduce should depend
 6755: @c on the relative precedence of the operators @samp{-} and
 6756: @c @var{op}: @samp{*} should be shifted first, but not @samp{<}.
 6757: 
 6758: @c 原文で和と差が逆になっている(訳者)。
 6759: 
 6760: Bison字句解析器がどちらの処理をすべきか決めるために、
 6761: 構文解析の結果を考慮する必要があります。
 6762: もし、次の演算子トークン@var{op}がシフトされるならば、
 6763: 還元して差を求める可能性を許すために、
 6764: @var{op}は最初に還元される必要があります。
 6765: その結果は、@w{@samp{1 - (2 @var{op} 3)}}となります。
 6766: 逆に、@var{op}をシフトする前に減算を還元するならば、
 6767: 結果は@w{@samp{(1 - 2) @var{op} 3}}となります。
 6768: 明らかに、シフトと還元のどちらが起こるべきかの選択は、
 6769: 演算子@samp{-}と@var{op}の相対的な優先順位に依存します。
 6770: @samp{*}は先にシフトされるべきですが、@samp{<}は違います。
 6771: 
 6772: @cindex associativity
 6773: @c What about input such as @w{@samp{1 - 2 - 5}}; should this be
 6774: @c @w{@samp{(1 - 2) - 5}} or should it be @w{@samp{1 - (2 - 5)}}?  For
 6775: @c most operators we prefer the former, which is called @dfn{left
 6776: @c association}.  The latter alternative, @dfn{right association}, is
 6777: @c desirable for assignment operators.  The choice of left or right
 6778: @c association is a matter of whether the parser chooses to shift or
 6779: @c reduce when the stack contains @w{@samp{1 - 2}} and the look-ahead
 6780: @c token is @samp{-}: shifting makes right-associativity.
 6781: 
 6782: @cindex 結合性
 6783: @w{@samp{1 - 2 - 5}}のような例ではどうなるでしょうか。
 6784: @w{@samp{(1 - 2) - 5}}と処理するべきでしょうか。
 6785: それとも、@w{@samp{1 - (2 - 5)}}と処理するべきでしょうか。
 6786: ほとんどの演算子については前者が適し、これを、
 6787: @dfn{左結合性(left association)}と呼びます。
 6788: 後者の@dfn{右結合性(right association)}は、代入演算子に適します。
 6789: 左結合性か右結合性かの判断は、スタックに@w{@samp{1 - 2}}が含まれ、
 6790: 先読みトークンが@samp{-}である場合の、シフトか還元かの選択です。
 6791: シフトを選ぶと、右結合的になります。
 6792: 
 6793: 
 6794: @c =====================================================================
 6795: @node Using Precedence, Precedence Examples, Why Precedence, Precedence
 6796: @c @subsection Specifying Operator Precedence
 6797: @subsection 演算子の優先順位の指定
 6798: @findex %left
 6799: @findex %right
 6800: @findex %nonassoc
 6801: 
 6802: @c Bison allows you to specify these choices with the operator precedence
 6803: @c declarations @code{%left} and @code{%right}.  Each such declaration
 6804: @c contains a list of tokens, which are operators whose precedence and
 6805: @c associativity is being declared.  The @code{%left} declaration makes all
 6806: @c those operators left-associative and the @code{%right} declaration makes
 6807: @c them right-associative.  A third alternative is @code{%nonassoc}, which
 6808: @c declares that it is a syntax error to find the same operator twice ``in a
 6809: @c row''.
 6810: 
 6811: 演算子優先順位宣言@code{%left}と@code{%right}によって、
 6812: 演算子の優先順位と結合規則を指定できます。
 6813: どちらの宣言も、優先順位と結合規則を指定したい演算子である、
 6814: トークンの並びからなります。
 6815: @code{%left}宣言はすべての演算子を左結合的に、
 6816: @code{%right}宣言はすべての演算子を右結合的に宣言します。
 6817: 第3の選択肢は@code{%nonassoc}宣言で、これで宣言した演算子が
 6818: 続けて2回以上現れると、構文解析器が文法エラーを指摘します。
 6819: 
 6820: @c The relative precedence of different operators is controlled by the
 6821: @c order in which they are declared.  The first @code{%left} or
 6822: @c @code{%right} declaration in the file declares the operators whose
 6823: @c precedence is lowest, the next such declaration declares the operators
 6824: @c whose precedence is a little higher, and so on.
 6825: 
 6826: 異なる演算子の相対的な優先順位は、それらが宣言される順序で決まります。
 6827: 文法ファイルの中の最初の@code{%left}宣言または@code{%right}宣言で
 6828: 宣言された演算子が、もっとも低い優先順位を持ちます。
 6829: 後から宣言される演算子ほど、高い優先順位を持ちます。
 6830: 
 6831: 
 6832: @c =====================================================================
 6833: @node Precedence Examples, How Precedence, Using Precedence, Precedence
 6834: @c @subsection Precedence Examples
 6835: @subsection 優先順位の例
 6836: 
 6837: @c In our example, we would want the following declarations:
 6838: 
 6839: 先ほどの例では、次のように宣言するべきでした。
 6840: 
 6841: @example
 6842: %left '<'
 6843: %left '-'
 6844: %left '*'
 6845: @end example
 6846: 
 6847: @c @c In a more complete example, which supports other operators as well, we
 6848: @c @c would declare them in groups of equal precedence.
 6849: @c For example, @code{'+'} is declared with @code{'-'}:
 6850: 
 6851: もっと複雑な例では、より多くの演算子を使うだけでなく、
 6852: 同じ優先順位を持つ演算子があります。
 6853: 次の例では、@code{'+'}演算子と@code{'-'}演算子が同じ優先順位を持ちます。
 6854: 
 6855: @example
 6856: %left '<' '>' '=' NE LE GE
 6857: %left '+' '-'
 6858: %left '*' '/'
 6859: @end example
 6860: 
 6861: @c @noindent
 6862: @c (Here @code{NE} and so on stand for the operators for ``not equal''
 6863: @c and so on.  We assume that these tokens are more than one character long
 6864: @c and therefore are represented by names, not character literals.)
 6865: 
 6866: (この例で、@code{NE}は「等しくない」演算子を表し、他も同様です。
 6867: これらのトークンは、2文字以上からなるので、
 6868: 1文字リテラルではなく名前で表されると仮定しています)
 6869: 
 6870: 
 6871: @c =====================================================================
 6872: @node How Precedence,  , Precedence Examples, Precedence
 6873: @c @subsection How Precedence Works
 6874: @subsection 優先順位が働く仕組み
 6875: 
 6876: @c The first effect of the precedence declarations is to assign precedence
 6877: @c levels to the terminal symbols declared.  The second effect is to assign
 6878: @c precedence levels to certain rules: each rule gets its precedence from the
 6879: @c last terminal symbol mentioned in the components.  (You can also specify
 6880: @c explicitly the precedence of a rule.
 6881: @c @xref{Contextual Precedence, ,Context-Dependent Precedence}.)
 6882: 
 6883: 優先順位宣言の最初の働きは、宣言された終端記号への優先順位の割り当てです。
 6884: 第2の働きは、規則に含まれる最後の終端記号が優先順位を示すように、
 6885: ある規則に優先順位を割り当てることです
 6886: (規則に対して、明示的に優先順位を指定することも可能です。
 6887: @xref{Contextual Precedence, ,Context-Dependent Precedence})。
 6888: 
 6889: @c Finally, the resolution of conflicts works by comparing the
 6890: @c precedence of the rule being considered with that of the
 6891: @c look-ahead token.  If the token's precedence is higher, the
 6892: @c choice is to shift.  If the rule's precedence is higher, the
 6893: @c choice is to reduce.  If they have equal precedence, the choice
 6894: @c is made based on the associativity of that precedence level.  The
 6895: @c verbose output file made by @samp{-v}
 6896: @c (@pxref{Invocation, ,Invoking Bison}) says
 6897: @c how each conflict was resolved.
 6898: 
 6899: 最後に、衝突の解決は、問題になっている規則の優先順位と、
 6900: 先読みトークンの優先順位の比較によって行われます。
 6901: もし、先読みトークンの優先順位が高ければ、還元されます。
 6902: もし、規則の優先順位が高ければ、シフトされます。
 6903: もし、優先順位が同じならば、その優先順位での結合規則によって決定されます。
 6904: @samp{-v}オプションを付けてBisonを実行し、冗長な出力ファイルを得ると、
 6905: どのように衝突が解決されているかがわかります
 6906: (@pxref{Invocation, ,Invoking Bison})。
 6907: 
 6908: @c Not all rules and not all tokens have precedence.  If either the rule or
 6909: @c the look-ahead token has no precedence, then the default is to shift.
 6910: 
 6911: すべての規則とトークンが優先順位を持っているとはかぎりません。
 6912: もし、規則と先読みトークンが優先順位を持っていなければ、
 6913: シフトが行われます。
 6914: 
 6915: 
 6916: @c =====================================================================
 6917: @node Contextual Precedence, Parser States, Precedence, Algorithm
 6918: @c @section Context-Dependent Precedence
 6919: @section 文脈依存優先順位
 6920: @cindex context-dependent precedence
 6921: @cindex unary operator precedence
 6922: @cindex precedence, context-dependent
 6923: @cindex precedence, unary operator
 6924: @findex %prec
 6925: @cindex 文脈依存優先順位
 6926: @cindex 単項演算子の優先順位
 6927: @cindex 優先順位, 文脈依存
 6928: @cindex 優先順位, 単項演算子
 6929: 
 6930: @c Often the precedence of an operator depends on the context.  This sounds
 6931: @c outlandish at first, but it is really very common.  For example, a minus
 6932: @c sign typically has a very high precedence as a unary operator, and a
 6933: @c somewhat lower precedence (lower than multiplication) as a binary operator.
 6934: 
 6935: しばしば、演算子の優先順位は文脈に依存します。
 6936: これは、最初は奇異に感じるかもしれませんが、
 6937: 実際によく起きていることなのです。
 6938: たとえば、通常、減算演算子(@samp{-})は、
 6939: 単項演算子としては非常に高い優先順位を持ちますが、
 6940: 2項演算子としては乗除算よりも低い優先順位を持ちます。
 6941: 
 6942: @c The Bison precedence declarations, @code{%left}, @code{%right} and
 6943: @c @code{%nonassoc}, can only be used once for a given token; so a token has
 6944: @c only one precedence declared in this way.  For context-dependent
 6945: @c precedence, you need to use an additional mechanism: the @code{%prec}
 6946: @c modifier for rules.@refill
 6947: 
 6948: Bisonの優先順位宣言、@code{%left}、@code{%right}、@code{%nonassoc}は、
 6949: あるトークンに対して1回のみ使え、この方法では、
 6950: トークンは唯一の優先順位を宣言されます。
 6951: 文脈に依存する優先順位のためには、別の方法、すなわち、
 6952: @code{%prec}で規則を修飾する方法が必要になります。
 6953: 
 6954: @c The @code{%prec} modifier declares the precedence of a particular rule by
 6955: @c specifying a terminal symbol whose precedence should be used for that rule.
 6956: @c It's not necessary for that symbol to appear otherwise in the rule.  The
 6957: @c modifier's syntax is:
 6958: 
 6959: @code{%prec}修飾子は、ある規則で使われるべき終端記号の優先順位を指定して、
 6960: その規則の優先順位を宣言します。
 6961: その記号がその規則の中以外に現れる必要はありません。
 6962: 修飾子の記法は、次のようになっています。
 6963: 
 6964: @example
 6965: %prec @var{terminal-symbol}
 6966: @end example
 6967: 
 6968: @c @noindent
 6969: @c and it is written after the components of the rule.  Its effect is to
 6970: @c assign the rule the precedence of @var{terminal-symbol}, overriding
 6971: @c the precedence that would be deduced for it in the ordinary way.  The
 6972: @c altered rule precedence then affects how conflicts involving that rule
 6973: @c are resolved (@pxref{Precedence, ,Operator Precedence}).
 6974: 
 6975: これは、規則の構成要素の後に書かれます。
 6976: これによって、通常の方法で導かれる優先順位に代わって、
 6977: @var{terminal-symbol}の優先順位を規則に割り当てます。
 6978: 規則の優先順位が変更されて、その規則が関係している衝突の解決に影響します
 6979: (@pxref{Precedence, ,Operator Precedence})。
 6980: 
 6981: @c Here is how @code{%prec} solves the problem of unary minus.  First, declare
 6982: @c a precedence for a fictitious terminal symbol named @code{UMINUS}.  There
 6983: @c are no tokens of this type, but the symbol serves to stand for its
 6984: @c precedence:
 6985: 
 6986: @code{%prec}がどのように単項負記号を解決するかを示します。
 6987: まず、@code{UMINUS}という名前の終端記号に対する優先順位を宣言します。
 6988: この型のトークンは存在しませんが、
 6989: この記号が優先順位を表現するために使われます。
 6990: 
 6991: @example
 6992: @dots{}
 6993: %left '+' '-'
 6994: %left '*'
 6995: %left UMINUS
 6996: @end example
 6997: 
 6998: @c Now the precedence of @code{UMINUS} can be used in specific rules:
 6999: 
 7000: さて、@code{UNIMIS}の優先順位を、規則の中で使えます。
 7001: 
 7002: @example
 7003: @group
 7004: exp:    @dots{}
 7005:         | exp '-' exp
 7006:         @dots{}
 7007:         | '-' exp %prec UMINUS
 7008: @end group
 7009: @end example
 7010: 
 7011: 
 7012: @c =====================================================================
 7013: @node Parser States, Reduce/Reduce, Contextual Precedence, Algorithm
 7014: @c @section Parser States
 7015: @section 構文解析器の状態
 7016: @cindex finite-state machine
 7017: @cindex parser state
 7018: @cindex state (of parser)
 7019: @cindex 有限状態機械
 7020: @cindex 構文解析器の状態
 7021: @cindex 状態, 構文解析器
 7022: 
 7023: @c The function @code{yyparse} is implemented using a finite-state machine.
 7024: @c The values pushed on the parser stack are not simply token type codes; they
 7025: @c represent the entire sequence of terminal and nonterminal symbols at or
 7026: @c near the top of the stack.  The current state collects all the information
 7027: @c about previous input which is relevant to deciding what to do next.
 7028: 
 7029: 関数@code{yyparse}は、有限状態機械を使って実装されています。
 7030: 構文解析器のスタックに積まれる値は、トークン型番号だけでなく、
 7031: スタックの先頭またはその近くにある終端記号と非終端記号の列を
 7032: 表現しています。現在の状態は、次にすべきことに関連する、
 7033: 今までの入力の情報全体の集まりです。
 7034: 
 7035: @c Each time a look-ahead token is read, the current parser state together
 7036: @c with the type of look-ahead token are looked up in a table.  This table
 7037: @c entry can say, ``Shift the look-ahead token.''  In this case, it also
 7038: @c specifies the new parser state, which is pushed onto the top of the
 7039: @c parser stack.  Or it can say, ``Reduce using rule number @var{n}.''
 7040: @c This means that a certain number of tokens or groupings are taken off
 7041: @c the top of the stack, and replaced by one grouping.  In other words,
 7042: @c that number of states are popped from the stack, and one new state is
 7043: @c pushed.
 7044: 
 7045: 先読みトークンが読まれるたびに、先読みトークンの型と
 7046: 現在の構文解析器の状態によって、表が引かれます。
 7047: この表の項目には、「先読みトークンをシフトしなさい」というような
 7048: ことが書かれています。この場合、その表の項目は、
 7049: 先読みトークンが構文解析器スタックのトップに置かれた、
 7050: 構文解析器の新しい状態をも示しています。
 7051: 「@var{n}番目の規則を使って還元しなさい」というような項目もあります。
 7052: これによって、決められた数のトークンまたはグループがスタックのトップから
 7053: 取り除かれ、1個のグループがスタックのトップに置かれます。
 7054: 言い換えると、その数の状態がスタックからポップされ、
 7055: 新しい1個の状態がスタックにプッシュされます。
 7056: 
 7057: @c There is one other alternative: the table can say that the look-ahead token
 7058: @c is erroneous in the current state.  This causes error processing to begin
 7059: @c (@pxref{Error Recovery}).
 7060: 
 7061: これには、1つの例外があります。
 7062: 先読みトークンが現在の状態に対してエラーであるという項目もあります。
 7063: この場合には、エラー処理が起こります
 7064: (@pxref{Error Recovery})。
 7065: 
 7066: 
 7067: @c =====================================================================
 7068: @node Reduce/Reduce, Mystery Conflicts, Parser States, Algorithm
 7069: @c @section Reduce/Reduce Conflicts
 7070: @section 還元/還元衝突
 7071: @cindex reduce/reduce conflict
 7072: @cindex conflicts, reduce/reduce
 7073: @cindex 還元/還元衝突
 7074: @cindex 衝突, 還元/還元
 7075: 
 7076: @c A reduce/reduce conflict occurs if there are two or more rules that apply
 7077: @c to the same sequence of input.  This usually indicates a serious error
 7078: @c in the grammar.
 7079: 
 7080: 同一の入力列に対して2個以上の規則が適用可能であると、
 7081: 還元/還元衝突が起きます。
 7082: これは、通常、文法の重大なエラーを意味します。
 7083: 
 7084: @c For example, here is an erroneous attempt to define a sequence
 7085: @c of zero or more @code{word} groupings.
 7086: 
 7087: 0個以上の@code{word}の並びをグループ化する、
 7088: 誤った試みの例を示します。
 7089: 
 7090: @example
 7091: @c sequence: /* empty */
 7092: sequence: /* 空 */
 7093:                 @{ printf ("empty sequence\n"); @}
 7094:         | maybeword
 7095:         | sequence word
 7096:                 @{ printf ("added word %s\n", $2); @}
 7097:         ;
 7098: 
 7099: @c maybeword: /* empty */
 7100: maybeword: /* 空 */
 7101:                 @{ printf ("empty maybeword\n"); @}
 7102:         | word
 7103:                 @{ printf ("single word %s\n", $1); @}
 7104:         ;
 7105: @end example
 7106: 
 7107: @c @noindent
 7108: @c The error is an ambiguity: there is more than one way to parse a single
 7109: @c @code{word} into a @code{sequence}.  It could be reduced to a
 7110: @c @code{maybeword} and then into a @code{sequence} via the second rule.
 7111: @c Alternatively, nothing-at-all could be reduced into a @code{sequence}
 7112: @c via the first rule, and this could be combined with the @code{word}
 7113: @c using the third rule for @code{sequence}.
 7114: 
 7115: エラーは、あいまいさにあります。
 7116: つまり、1個の@code{word}を@code{sequence}に構文解析する、
 7117: 2個以上の方法があります。
 7118: @code{word}は、@code{maybeword}に還元され、
 7119: 第2の規則によって@code{sequence}になりえます。
 7120: また、最初の規則で、空データが@code{sequence}に還元され、
 7121: それが第3の規則によって@code{word}と組み合わされて
 7122: @code{sequence}になりえます。
 7123: 
 7124: @c There is also more than one way to reduce nothing-at-all into a
 7125: @c @code{sequence}.  This can be done directly via the first rule,
 7126: @c or indirectly via @code{maybeword} and then the second rule.
 7127: 
 7128: さらに、空データが@code{sequence}に還元される方法が2つ以上あります。
 7129: 第1の規則で直接還元される方法と、
 7130: @code{maybeword}を経由して第2の規則で還元される方法です。
 7131: 
 7132: @c You might think that this is a distinction without a difference, because it
 7133: @c does not change whether any particular input is valid or not.  But it does
 7134: @c affect which actions are run.  One parsing order runs the second rule's
 7135: @c action; the other runs the first rule's action and the third rule's action.
 7136: @c In this example, the output of the program changes.
 7137: 
 7138: この違いは、特定の入力が正当であるかどうかに関係ないので、
 7139: ささいなことに思えるかもしれません。
 7140: しかし、これは、どのアクションが実行されるかに影響します。
 7141: ある構文解析手順では第2の規則のアクションが実行され、
 7142: 別の構文解析手順では第1の規則のアクションと第3の規則のアクションが
 7143: 実行されます。
 7144: この例では、プログラムの出力が異なります。
 7145: 
 7146: @c Bison resolves a reduce/reduce conflict by choosing to use the rule that
 7147: @c appears first in the grammar, but it is very risky to rely on this.  Every
 7148: @c reduce/reduce conflict must be studied and usually eliminated.  Here is the
 7149: @c proper way to define @code{sequence}:
 7150: 
 7151: Bisonは、最初に現れた文法を選ぶことで、還元/還元衝突を解決しますが、
 7152: これに頼ることは非常に危険です。
 7153: 還元/還元衝突のそれぞれは、人間によって解析され、
 7154: 通常は取り除かれるべきです。
 7155: @code{sequence}を定義する正しい方法を示します。
 7156: 
 7157: @example
 7158: @c sequence: /* empty */
 7159: sequence: /* 空 */
 7160:                 @{ printf ("empty sequence\n"); @}
 7161:         | sequence word
 7162:                 @{ printf ("added word %s\n", $2); @}
 7163:         ;
 7164: @end example
 7165: 
 7166: @c Here is another common error that yields a reduce/reduce conflict:
 7167: 
 7168: 還元/還元衝突を起こす、別のありがちなエラーの例を示します。
 7169: 
 7170: @example
 7171: @c sequence: /* empty */
 7172: sequence: /* 空 */
 7173:         | sequence words
 7174:         | sequence redirects
 7175:         ;
 7176: 
 7177: @c words:    /* empty */
 7178: words:    /* 空 */
 7179:         | words word
 7180:         ;
 7181: 
 7182: @c redirects:/* empty */
 7183: redirects:/* 空 */
 7184:         | redirects redirect
 7185:         ;
 7186: @end example
 7187: 
 7188: @c @noindent
 7189: @c The intention here is to define a sequence which can contain either
 7190: @c @code{word} or @code{redirect} groupings.  The individual definitions of
 7191: @c @code{sequence}, @code{words} and @code{redirects} are error-free, but the
 7192: @c three together make a subtle ambiguity: even an empty input can be parsed
 7193: @c in infinitely many ways!
 7194: 
 7195: ここは、@code{word}または@code{redirect}グループのどちらかを含む
 7196: 列の定義が目的です。
 7197: @code{sequence}、@code{words}、@code{redirects}それぞれ個別の
 7198: 定義にエラーはありません。しかし、3個を合わせると、あいまいになります。
 7199: 空の入力には、無限個の構文解析方法があります。
 7200: 
 7201: @c Consider: nothing-at-all could be a @code{words}.  Or it could be two
 7202: @c @code{words} in a row, or three, or any number.  It could equally well be a
 7203: @c @code{redirects}, or two, or any number.  Or it could be a @code{words}
 7204: @c followed by three @code{redirects} and another @code{words}.  And so on.
 7205: 
 7206: 空データが@code{words}になったと仮定しましょう。
 7207: それは、2個の@code{words}にも、3個の@code{words}にも、
 7208: 何個の@code{words}にもなりえます。
 7209: あるいは、1個の@code{words}に3個の@code{redirects}ともう1個の@code{word}が
 7210: 続くことも考えられます。同様に、無限の解釈が可能です。
 7211: 
 7212: @c Here are two ways to correct these rules.  First, to make it a single level
 7213: @c of sequence:
 7214: 
 7215: これらの規則を直す方法が2つあります。
 7216: 第1に、1段階の列にする方法です。
 7217: 
 7218: @example
 7219: @c sequence: /* empty */
 7220: sequence: /* 空 */
 7221:         | sequence word
 7222:         | sequence redirect
 7223:         ;
 7224: @end example
 7225: 
 7226: @c Second, to prevent either a @code{words} or a @code{redirects}
 7227: @c from being empty:
 7228: 
 7229: 第2に、@code{words}と@code{redirects}が空になるのを防ぐ方法です。
 7230:  
 7231: @example
 7232: @c sequence: /* empty */
 7233: sequence: /* 空 */
 7234:         | sequence words
 7235:         | sequence redirects
 7236:         ;
 7237: 
 7238: words:    word
 7239:         | words word
 7240:         ;
 7241: 
 7242: redirects:redirect
 7243:         | redirects redirect
 7244:         ;
 7245: @end example
 7246: 
 7247: 
 7248: @c =====================================================================
 7249: @node Mystery Conflicts, Stack Overflow, Reduce/Reduce, Algorithm
 7250: @c @section Mysterious Reduce/Reduce Conflicts
 7251: @section 不可解な還元/還元衝突
 7252: 
 7253: @c Sometimes reduce/reduce conflicts can occur that don't look warranted.
 7254: @c Here is an example:
 7255: 
 7256: そうなるはずがないように見えるのに、ときどき
 7257: 還元/還元衝突が起きることがあります。
 7258: 例を示します。
 7259: 
 7260: @example
 7261: @group
 7262: %token ID
 7263: 
 7264: %%
 7265: def:    param_spec return_spec ','
 7266:         ;
 7267: param_spec:
 7268:              type
 7269:         |    name_list ':' type
 7270:         ;
 7271: @end group
 7272: @group
 7273: return_spec:
 7274:              type
 7275:         |    name ':' type
 7276:         ;
 7277: @end group
 7278: @group
 7279: type:        ID
 7280:         ;
 7281: @end group
 7282: @group
 7283: name:        ID
 7284:         ;
 7285: name_list:
 7286:              name
 7287:         |    name ',' name_list
 7288:         ;
 7289: @end group
 7290: @end example
 7291: 
 7292: @c It would seem that this grammar can be parsed with only a single token
 7293: @c of look-ahead: when a @code{param_spec} is being read, an @code{ID} is 
 7294: @c a @code{name} if a comma or colon follows, or a @code{type} if another
 7295: @c @code{ID} follows.  In other words, this grammar is LR(1).
 7296: 
 7297: この文法は、1個のトークンの先読みによって、構文解析できるように見えます。
 7298: たとえば、@code{pram_spec}が読まれた後で、
 7299: @code{ID}はカンマかセミコロンが続くならば@code{name}、
 7300: そうでなければ@code{type}となります。
 7301: 言い換えれば、この文法はLR(1)です。
 7302: 
 7303: @cindex LR(1)
 7304: @cindex LALR(1)
 7305: @c However, Bison, like most parser generators, cannot actually handle all
 7306: @c LR(1) grammars.  In this grammar, two contexts, that after an @code{ID}
 7307: @c at the beginning of a @code{param_spec} and likewise at the beginning of
 7308: @c a @code{return_spec}, are similar enough that Bison assumes they are the
 7309: @c same.  They appear similar because the same set of rules would be
 7310: @c active---the rule for reducing to a @code{name} and that for reducing to
 7311: @c a @code{type}.  Bison is unable to determine at that stage of processing
 7312: @c that the rules would require different look-ahead tokens in the two
 7313: @c contexts, so it makes a single parser state for them both.  Combining
 7314: @c the two contexts causes a conflict later.  In parser terminology, this
 7315: @c occurrence means that the grammar is not LALR(1).
 7316: 
 7317: しかし、Bisonは、多くの構文解析器生成器と同様に、
 7318: すべてのLR(1)文法を扱えるわけではありません。
 7319: 前述の例では、@code{ID}の後で、そこが@code{param_spec}の先頭であるという
 7320: 文脈と、そこが@code{return_spec}の先頭であるという文脈は、
 7321: Bisonが同一であるとみなしてしまうほど似ています。
 7322: これらの文脈が似てしまう原因は、同じ規則の集合が有効になる、つまり、
 7323: @code{name}へ還元するための規則と、@code{type}へ還元するための規則の
 7324: 両方が有効なことです。
 7325: Bisonは、その規則が2つの文脈で異なる先読みトークンを要求するような、
 7326: 処理の段階を決定できず、両者から1つの構文解析器状態ができてしまいます。
 7327: 2個の文脈の組み合わせは、後で衝突を起こします。
 7328: 構文解析器の用語でいえば、この問題の発生は、
 7329: 文法がLALR(1)でないことを意味します。
 7330: 
 7331: @c In general, it is better to fix deficiencies than to document them.  But
 7332: @c this particular deficiency is intrinsically hard to fix; parser
 7333: @c generators that can handle LR(1) grammars are hard to write and tend to
 7334: @c produce parsers that are very large.  In practice, Bison is more useful
 7335: @c as it is now.
 7336: 
 7337: 一般に、このような欠点は解決して、文書化するべきです。
 7338: しかし、この問題は本質的に解決困難です。
 7339: LR(1)文法を扱える構文解析器生成器は、作成困難で、
 7340: 生成される構文解析器が巨大になってしまいます。
 7341: 実用上、Bisonは今のままでも有用です。
 7342: 
 7343: @c When the problem arises, you can often fix it by identifying the two
 7344: @c parser states that are being confused, and adding something to make them
 7345: @c look distinct.  In the above example, adding one rule to
 7346: @c @code{return_spec} as follows makes the problem go away:
 7347: 
 7348: このような問題が現れた場合に、混乱の元になっている2種類の構文解析器の
 7349: 状態を区別し、それらが違うという目印か何かを追加することによって、
 7350: しばしば問題を解決できます。
 7351: 前述の例では、次のように@code{return_spec}に規則を追加して、
 7352: 問題を解決できます。
 7353: 
 7354: @example
 7355: @group
 7356: %token BOGUS
 7357: @dots{}
 7358: %%
 7359: @dots{}
 7360: return_spec:
 7361:              type
 7362:         |    name ':' type
 7363: @c         /* This rule is never used.  */
 7364:          /* この規則は決して使われない。  */
 7365:         |    ID BOGUS
 7366:         ;
 7367: @end group
 7368: @end example
 7369: 
 7370: @c This corrects the problem because it introduces the possibility of an
 7371: @c additional active rule in the context
 7372: @c after the @code{ID} at the beginning of
 7373: @c @code{return_spec}.  This rule is not active in the corresponding context
 7374: @c in a @code{param_spec}, so the two contexts receive distinct parser states.
 7375: @c As long as the token @code{BOGUS} is never generated by @code{yylex},
 7376: @c the added rule cannot alter the way actual input is parsed.
 7377: 
 7378: @code{ID}の次で@code{return_spec}の先頭である文脈で、
 7379: 追加の規則が有効になる可能性を導入して、問題を解決しています。
 7380: この規則は、@code{param_spec}に関連する文脈では有効にならないので、
 7381: 2個の文脈は、異なる構文解析器状態を持ちます。
 7382: @code{BOGUS}は@code{yylex}によっては決して生成されないので、
 7383: 追加された規則は入力が実際に構文解析される方法には影響しません。
 7384: 
 7385: @c In this particular example, there is another way to solve the problem:
 7386: @c rewrite the rule for @code{return_spec} to use @code{ID} directly
 7387: @c instead of via @code{name}.  This also causes the two confusing
 7388: @c contexts to have different sets of active rules, because the one for
 7389: @c @code{return_spec} activates the altered rule for @code{return_spec}
 7390: @c rather than the one for @code{name}.
 7391: 
 7392: この具体例では、問題を解決する別の方法があります。
 7393: つまり、@code{return_spec}の規則を、@code{name}経由ではなく
 7394: @code{ID}を直接使うように書き換えるのです。
 7395: @code{return_spec}に対する規則は、@code{name}に対する規則ではなく、
 7396: @code{return_spec}に対する規則を有効にするので、
 7397: 2つの混乱していた文脈は異なる有効な規則の集まりを持ちます。
 7398: 
 7399: @example
 7400: param_spec:
 7401:              type
 7402:         |    name_list ':' type
 7403:         ;
 7404: return_spec:
 7405:              type
 7406:         |    ID ':' type
 7407:         ;
 7408: @end example
 7409: 
 7410: 
 7411: @c =====================================================================
 7412: @node Stack Overflow,  , Mystery Conflicts, Algorithm
 7413: @c @section Stack Overflow, and How to Avoid It
 7414: @section スタックオーバーフローと防ぎ方
 7415: @cindex stack overflow
 7416: @cindex parser stack overflow
 7417: @cindex overflow of parser stack
 7418: @cindex スタックオーバーフロー
 7419: @cindex 構文解析器のスタックオーバーフロー
 7420: @cindex オーバーフロー, 構文解析器のスタック
 7421: 
 7422: @c The Bison parser stack can overflow if too many tokens are shifted and
 7423: @c not reduced.  When this happens, the parser function @code{yyparse}
 7424: @c returns a nonzero value, pausing only to call @code{yyerror} to report
 7425: @c the overflow.
 7426: 
 7427: Bison構文解析器のスタックは、あまりにも多くのトークンがシフトされて
 7428: 還元されないでいると、オーバーフローする可能性があります。
 7429: スタックがオーバーフローすると、オーバーフローを報告するために@code{yyerror}
 7430: を呼び出して、関数@code{yyparse}は0でない値を返します。
 7431: 
 7432: @vindex YYMAXDEPTH
 7433: @c By defining the macro @code{YYMAXDEPTH}, you can control how deep the
 7434: @c parser stack can become before a stack overflow occurs.  Define the
 7435: @c macro with a value that is an integer.  This value is the maximum number
 7436: @c of tokens that can be shifted (and not reduced) before overflow.
 7437: @c It must be a constant expression whose value is known at compile time.
 7438: 
 7439: マクロ@code{YYMAXDEPTH}を定義して、スタックオーバーフローが起こらないように、
 7440: 構文解析器のスタックの深さを調節できます。
 7441: マクロの値として、整数値を定義してください。
 7442: この値は、オーバーフローする前に、シフトされたが還元されていないトークンの
 7443: 最大数になります。
 7444: マクロの値として、コンパイル時に決定可能な定数式を指定してください。
 7445: 
 7446: @c The stack space allowed is not necessarily allocated.  If you specify a
 7447: @c large value for @code{YYMAXDEPTH}, the parser actually allocates a small
 7448: @c stack at first, and then makes it bigger by stages as needed.  This
 7449: @c increasing allocation happens automatically and silently.  Therefore,
 7450: @c you do not need to make @code{YYMAXDEPTH} painfully small merely to save
 7451: @c space for ordinary inputs that do not need much stack.
 7452: 
 7453: 指定されたスタック領域は、割り当てられる必要はありません。
 7454: 大きな@code{YYMAXDEPTH}を指定すると、
 7455: 構文解析器はまず小さなスタック領域を割り当て、
 7456: 必要に応じてより大きなスタック領域を割り当てます。
 7457: この割り当ての増加は、何も表示せずに、自動的に行われます。
 7458: したがって、スタックをあまり必要としない通常の入力に対して
 7459: メモリを節約するために、@code{YYMAXDEPTH}を小さくする必要はありません。
 7460: 
 7461: @cindex default stack limit
 7462: @cindex 省略時のスタックの限界
 7463: @cindex スタックの限界, 省略時
 7464: @c The default value of @code{YYMAXDEPTH}, if you do not define it, is
 7465: @c 10000.
 7466: 
 7467: 特に指定しないと、@code{YYMAXDEPTH}の値は10000になります。
 7468: 
 7469: @vindex YYINITDEPTH
 7470: @c You can control how much stack is allocated initially by defining the
 7471: @c macro @code{YYINITDEPTH}.  This value too must be a compile-time
 7472: @c constant integer.  The default is 200.
 7473: 
 7474: マクロ@code{YYINIDEPTH}を指定して、最初に割り当てられるスタックの量を
 7475: 調節できます。この値は、コンパイル時に決定可能な整定数の必要があります。
 7476: 特に指定しないと、200になります。
 7477: 
 7478: 
 7479: @c =====================================================================
 7480: @node Error Recovery, Context Dependency, Algorithm, Top
 7481: @c @chapter Error Recovery
 7482: @chapter エラーからの回復
 7483: @cindex error recovery
 7484: @cindex recovery from errors
 7485: @cindex エラーからの回復
 7486: @cindex 回復
 7487: 
 7488: @c It is not usually acceptable to have a program terminate on a parse
 7489: @c error.  For example, a compiler should recover sufficiently to parse the
 7490: @c rest of the input file and check it for errors; a calculator should accept
 7491: @c another expression.
 7492: 
 7493: 構文解析エラーが起きた場合に、構文解析プログラムが止まることは、
 7494: 通常望ましくありません。
 7495: たとえば、コンパイラは入力の残りを構文解析して他のエラーを探せるように
 7496: エラーから回復するべきですし、電卓は次の式を受け入れるべきです。
 7497: 
 7498: @c In a simple interactive command parser where each input is one line, it may
 7499: @c be sufficient to allow @code{yyparse} to return 1 on error and have the
 7500: @c caller ignore the rest of the input line when that happens (and then call
 7501: @c @code{yyparse} again).  But this is inadequate for a compiler, because it
 7502: @c forgets all the syntactic context leading up to the error.  A syntax error
 7503: @c deep within a function in the compiler input should not cause the compiler
 7504: @c to treat the following line like the beginning of a source file.
 7505: 
 7506: 入力を1行ごとに処理する単純な対話的構文解析器は、
 7507: エラーが発生した場合に@code{yyparse}が1を返し、
 7508: 入力行の残りを無視し、
 7509: @code{yyparse}をもう一度呼び出してもかまいません。
 7510: しかし、コンパイラでこのように処理すると、
 7511: エラーに先立つ文法的文脈を忘れてしまうので不都合です。
 7512: 深い関数呼び出しの中で構文エラーが発生した場合に、
 7513: コンパイラがエラーに続く行をソースファイルの先頭のように
 7514: 扱うべきではありません。
 7515: 
 7516: @findex error
 7517: @c You can define how to recover from a syntax error by writing rules to
 7518: @c recognize the special token @code{error}.  This is a terminal symbol that
 7519: @c is always defined (you need not declare it) and reserved for error
 7520: @c handling.  The Bison parser generates an @code{error} token whenever a
 7521: @c syntax error happens; if you have provided a rule to recognize this token
 7522: @c in the current context, the parse can continue.  
 7523: 
 7524: 特別なトークン@code{error}を認識するような規則を書くことによって、
 7525: 構文エラーから回復する方法を定義できます。
 7526: @code{error}は定義済みの終端記号で、自分で宣言する必要はなく、
 7527: エラー処理のために予約されています。
 7528: Bison構文解析器は、構文エラーが起こるたびに、@code{error}トークンを生成します。
 7529: 現在の文脈で@code{error}トークンを認識できる規則を書いていれば、
 7530: 構文解析を継続できます。
 7531: 
 7532: @c For example:
 7533: 
 7534: 例を示します。
 7535: 
 7536: @example
 7537: @c stmnts:  /* empty string */
 7538: stmnts:  /* 空文字列 */
 7539:         | stmnts '\n'
 7540:         | stmnts exp '\n'
 7541:         | stmnts error '\n'
 7542: @end example
 7543: 
 7544: @c The fourth rule in this example says that an error followed by a newline
 7545: @c makes a valid addition to any @code{stmnts}.
 7546: 
 7547: 第4の規則は、@code{error}とそれに続く改行が、任意の@code{stmnts}に
 7548: 続くことを認めます。
 7549: 
 7550: @c What happens if a syntax error occurs in the middle of an @code{exp}?  The
 7551: @c error recovery rule, interpreted strictly, applies to the precise sequence
 7552: @c of a @code{stmnts}, an @code{error} and a newline.  If an error occurs in
 7553: @c the middle of an @code{exp}, there will probably be some additional tokens
 7554: @c and subexpressions on the stack after the last @code{stmnts}, and there
 7555: @c will be tokens to read before the next newline.  So the rule is not
 7556: @c applicable in the ordinary way.
 7557: 
 7558: @code{exp}の中で構文エラーが発生するとどうなるでしょうか。
 7559: エラー回復規則は、厳密に解釈され、@code{stmnts}、@code{error}、改行からなる
 7560: 列に適用されます。
 7561: @code{exp}の中で構文エラーが起きると、おそらく、いくつかの余分なトークンまたは
 7562: 部分式がスタック上の最後の@code{stmnts}の後に存在し、
 7563: したがって、次の改行を読む前に読むべきトークンが存在するでしょう。
 7564: したがって、この通常の方法では規則を適用できません。
 7565: 
 7566: @c But Bison can force the situation to fit the rule, by discarding part of
 7567: @c the semantic context and part of the input.  First it discards states and
 7568: @c objects from the stack until it gets back to a state in which the
 7569: @c @code{error} token is acceptable.  (This means that the subexpressions
 7570: @c already parsed are discarded, back to the last complete @code{stmnts}.)  At
 7571: @c this point the @code{error} token can be shifted.  Then, if the old
 7572: @c look-ahead token is not acceptable to be shifted next, the parser reads
 7573: @c tokens and discards them until it finds a token which is acceptable.  In
 7574: @c this example, Bison reads and discards input until the next newline
 7575: @c so that the fourth rule can apply.
 7576: 
 7577: しかし、意味文脈と入力の一部を捨てることによって、
 7578: Bisonは強制的にこの場合に規則を適用できます。
 7579: まず、@code{error}トークンが受理可能な状態に戻るまで、
 7580: 状態とオブジェクトがスタックから捨てられます
 7581: (これは、すでに構文解析された部分式が捨てられ、
 7582: 最後の完全な@code{stmnts}に状態が戻ることを意味します)。
 7583: この時点で、@code{error}トークンがシフトされます。
 7584: そして、古い先読みトークンのシフトは受理不可能なので、
 7585: 受理可能なトークンを見つけるまで、
 7586: 構文解析器はトークンを読んで捨てます。
 7587: 前述の例では、次の改行がくるまで入力が読み捨てられ、
 7588: したがって、第4の規則が適用可能になります。
 7589: 
 7590: @c The choice of error rules in the grammar is a choice of strategies for
 7591: @c error recovery.  A simple and useful strategy is simply to skip the rest of
 7592: @c the current input line or current statement if an error is detected:
 7593: 
 7594: 文法中のエラー規則の選択は、エラー回復の戦略の選択です。
 7595: 単純で便利な戦略の1つは、エラーを検出したら、
 7596: 単純に現在の入力行または文を読み飛ばすことです。
 7597: 
 7598: @example
 7599: @c stmnt: error ';'  /* on error, skip until ';' is read */
 7600: stmnt: error ';'  /* エラーがあれば、「;」がくるまで読み飛ばす。 */
 7601: @end example
 7602: 
 7603: @c It is also useful to recover to the matching close-delimiter of an
 7604: @c opening-delimiter that has already been parsed.  Otherwise the
 7605: @c close-delimiter will probably appear to be unmatched, and generate another,
 7606: @c spurious error message:
 7607: 
 7608: すでに構文解析された開き区切りトークン
 7609: @c @footnote{【訳注】C言語での@samp{([@{}、
 7610: @c Pascal言語での@samp{begin}など。}
 7611: @c を、閉じ区切りトークンに対応させることは、
 7612: エラー処理のうまい方法です。そうしなければ、閉じ区切りトークンが
 7613: 後で不適切に現れて、別の重大なエラーを引き起こすでしょう。
 7614: 
 7615: @example
 7616: primary:  '(' expr ')'
 7617:         | '(' error ')'
 7618:         @dots{}
 7619:         ;
 7620: @end example
 7621: 
 7622: @c Error recovery strategies are necessarily guesses.  When they guess wrong,
 7623: @c one syntax error often leads to another.  In the above example, the error
 7624: @c recovery rule guesses that an error is due to bad input within one
 7625: @c @code{stmnt}.  Suppose that instead a spurious semicolon is inserted in the
 7626: @c middle of a valid @code{stmnt}.  After the error recovery rule recovers
 7627: @c from the first error, another syntax error will be found straightaway,
 7628: @c since the text following the spurious semicolon is also an invalid
 7629: @c @code{stmnt}.
 7630: 
 7631: エラー回復の戦略は熟慮されるべきです。
 7632: 戦略が悪いと、1つの構文エラーがしばしば別のエラーを引き起こします。
 7633: 前述の例では、エラー回復規則は、1個の@code{stmnt}の中で起きると
 7634: 仮定されています。
 7635: そうでない可能性として、有効な@code{stmnt}の中に誤ってセミコロンが
 7636: まぎれ込んでいることを考えてみましょう。
 7637: エラー回復規則が最初のエラーを回復した後で、まぎれ込んだセミコロンに続く
 7638: 入力も無効な@code{stmnt}なので、もう1つの構文エラーがただちにみつかります。
 7639: 
 7640: @c To prevent an outpouring of error messages, the parser will output no error
 7641: @c message for another syntax error that happens shortly after the first; only
 7642: @c after three consecutive input tokens have been successfully shifted will
 7643: @c error messages resume.
 7644: 
 7645: エラー報告の洪水を避けるために、
 7646: 最初の構文エラーが起きた直後の他の構文エラーに対しては、
 7647: 構文解析器はエラー報告を表示しないべきでしょう。
 7648: 3個の連続する入力トークンのシフトに成功してから、
 7649: エラー報告を再開するべきです。
 7650: 
 7651: @c Note that rules which accept the @code{error} token may have actions, just
 7652: @c as any other rules can.
 7653: 
 7654: @code{error}トークンを受け付ける規則も、他の規則と同様に
 7655: アクションを持てることに注意してください。
 7656: 
 7657: @findex yyerrok
 7658: @c You can make error messages resume immediately by using the macro
 7659: @c @code{yyerrok} in an action.  If you do this in the error rule's action, no
 7660: @c error messages will be suppressed.  This macro requires no arguments;
 7661: @c @samp{yyerrok;} is a valid C statement.
 7662: 
 7663: アクションの中でマクロ@code{yyerrok}を使って、
 7664: ただちにエラー報告を再開できます。
 7665: もし、エラー規則のアクションの中でこのマクロを使えば、
 7666: エラー報告は抑制されません。
 7667: このマクロに引数は不要で、@samp{yyerrok;}は有効なCの文です。
 7668: 
 7669: @findex yyclearin
 7670: @c The previous look-ahead token is reanalyzed immediately after an error.  If
 7671: @c this is unacceptable, then the macro @code{yyclearin} may be used to clear
 7672: @c this token.  Write the statement @samp{yyclearin;} in the error rule's
 7673: @c action.
 7674: 
 7675: 直前の先読みトークンは、エラーの直後に再解析されます。
 7676: これが不都合ならば、マクロ@code{yyclearin}によって先読みトークンを
 7677: 消してください。すなわち、エラー規則のアクションに
 7678: @samp{yyclearin;}文を書いてください。
 7679: 
 7680: @c For example, suppose that on a parse error, an error handling routine is
 7681: @c called that advances the input stream to some point where parsing should
 7682: @c once again commence.  The next symbol returned by the lexical scanner is
 7683: @c probably correct.  The previous look-ahead token ought to be discarded
 7684: @c with @samp{yyclearin;}.
 7685: 
 7686: たとえば、構文エラーにおいて、構文解析を再開すべき場所まで入力を進めるような、
 7687: エラー処理手続きを考えてみましょう。
 7688: 字句解析器から返される次の記号は、おそらく正しいでしょう。
 7689: 以前の先読みトークンは@samp{yyclearin;}によって捨てられるべきです。
 7690: 
 7691: @vindex YYRECOVERING
 7692: @c The macro @code{YYRECOVERING} stands for an expression that has the
 7693: @c value 1 when the parser is recovering from a syntax error, and 0 the
 7694: @c rest of the time.  A value of 1 indicates that error messages are
 7695: @c currently suppressed for new syntax errors.
 7696: 
 7697: マクロ@code{YYRECOVERING}は、式を表し、構文解析器がエラーから回復する
 7698: 途中にあるならば値が1になり、通常の状態ならば値が0になります。
 7699: 値が1であるということは、新たな構文エラーに対するエラーの報告が、
 7700: 現在は抑制されていることを示します。
 7701: 
 7702: 
 7703: @c =====================================================================
 7704: @node Context Dependency, Debugging, Error Recovery, Top
 7705: @c @chapter Handling Context Dependencies
 7706: @chapter 文脈依存性の処理
 7707: 
 7708: @c The Bison paradigm is to parse tokens first, then group them into larger
 7709: @c syntactic units.  In many languages, the meaning of a token is affected by
 7710: @c its context.  Although this violates the Bison paradigm, certain techniques
 7711: @c (known as @dfn{kludges}) may enable you to write Bison parsers for such
 7712: @c languages.
 7713: 
 7714: Bisonの枠組みは、まずトークンを読み、
 7715: 次にトークンをより大きな文法的単位にグループ化することです。
 7716: 多くの言語では、トークンの意味は文脈の影響を受けます。
 7717: 文脈依存性によってBisonの枠組みが壊れますが、
 7718: (@dfn{kludges}として知られる)いくつかの技術を使って、
 7719: このような言語に対するBison構文解析器を書けます。
 7720: 
 7721: @menu
 7722: * Semantic Tokens::   Token parsing can depend on the semantic context.
 7723: * Lexical Tie-ins::   Token parsing can depend on the syntactic context.
 7724: * Tie-in Recovery::   Lexical tie-ins have implications for how
 7725:                         error recovery rules must be written.
 7726: @end menu
 7727: 
 7728: @c (Actually, ``kludge'' means any technique that gets its job done but is
 7729: @c neither clean nor robust.)
 7730: 
 7731: (実際に、「kludge」は、仕事を可能にしますが、
 7732: 美しくも頑丈でもない技術を意味します)
 7733: 
 7734: 
 7735: @c =====================================================================
 7736: @node Semantic Tokens, Lexical Tie-ins,  , Context Dependency
 7737: @c @section Semantic Info in Token Types
 7738: @section トークン型の意味情報
 7739: 
 7740: @c The C language has a context dependency: the way an identifier is used
 7741: @c depends on what its current meaning is.  For example, consider this:
 7742: 
 7743: C言語は文脈依存性をもっています。
 7744: すなわち、識別子の使われ方は、それの現在の意味に依存します。
 7745: 次の例を考えてみてください。
 7746: 
 7747: @example
 7748: foo (x);
 7749: @end example
 7750: 
 7751: @c This looks like a function call statement, but if @code{foo} is a typedef
 7752: @c name, then this is actually a declaration of @code{x}.  How can a Bison
 7753: @c parser for C decide how to parse this input?
 7754: 
 7755: これは、関数を呼び出す文のように見えます。
 7756: しかし、もし、@code{foo}が@code{typedef}された型名ならば、
 7757: この文は@code{x}の宣言になります。
 7758: C言語に対するBison構文解析器は、この入力を構文解析する方法を
 7759: どのように決定できるでしょうか。
 7760: 
 7761: @c The method used in GNU C is to have two different token types,
 7762: @c @code{IDENTIFIER} and @code{TYPENAME}.  When @code{yylex} finds an
 7763: @c identifier, it looks up the current declaration of the identifier in order
 7764: @c to decide which token type to return: @code{TYPENAME} if the identifier is
 7765: @c declared as a typedef, @code{IDENTIFIER} otherwise.
 7766: 
 7767: GNU Cで使っている方法は、@code{IDENTIFIER}と@code{TYPENAME}という、
 7768: 2種類の異なるトークン型を使うことです。
 7769: @code{yylex}が識別子を見つけると、どちらのトークン型を返すか決めるために、
 7770: 識別子の現在の宣言を検索し、@code{typedef}として宣言されていれば
 7771: @code{TYPENAME}を返し、そうでなければ@code{IDENTIFIER}を返します。
 7772: 
 7773: @c The grammar rules can then express the context dependency by the choice of
 7774: @c token type to recognize.  @code{IDENTIFIER} is accepted as an expression,
 7775: @c but @code{TYPENAME} is not.  @code{TYPENAME} can start a declaration, but
 7776: @c @code{IDENTIFIER} cannot.  In contexts where the meaning of the identifier
 7777: @c is @emph{not} significant, such as in declarations that can shadow a
 7778: @c typedef name, either @code{TYPENAME} or @code{IDENTIFIER} is
 7779: @c accepted---there is one rule for each of the two token types.
 7780: 
 7781: そして、認識するトークン型を選ぶことによって、
 7782: 文法規則は文脈依存性を表現できます。
 7783: @code{IDENTIFIER}は、式として受け入れられますが、
 7784: @code{TYPENAME}は受け入れられません。
 7785: @code{TYPENAME}は、宣言の始まりとして受け入れられますが、
 7786: @code{IDENTIFIER}は受け入れられません。
 7787: 識別子の意味の区別が@emph{必要のない}文脈、
 7788: たとえば@code{typedef}名を隠す宣言の中では、
 7789: @code{TYPENAME}と@code{IDENTIFIER}の両方が受け入れられます。
 7790: すなわち、2個のトークン型に対してそれぞれ1個の規則を書くことが可能です。
 7791: 
 7792: @c This technique is simple to use if the decision of which kinds of
 7793: @c identifiers to allow is made at a place close to where the identifier is
 7794: @c parsed.  But in C this is not always so: C allows a declaration to
 7795: @c redeclare a typedef name provided an explicit type has been specified
 7796: @c earlier:
 7797: 
 7798: この方法は、どの種類の識別子が許されるかの判断が、
 7799: その識別子が構文解析される場所の近くで行われるならば、
 7800: 単純に使えます。
 7801: しかし、C言語で、いつもそうであるとは限りません。
 7802: 次の例のように、以前に指定された明示的な型に規定された@code{typedef}名の
 7803: 再宣言が許されているからです。
 7804: 
 7805: @example
 7806: typedef int foo, bar, lose;
 7807: @c static foo (bar);        /* @r{redeclare @code{bar} as static variable} */
 7808: static foo (bar);        /* @r{@code{bar}を静的変数として再宣言する。} */
 7809: @c static int foo (lose);   /* @r{redeclare @code{foo} as function} */
 7810: static int foo (lose);   /* @r{@code{foo}を関数として再宣言する。} */
 7811: @end example
 7812: 
 7813: @c Unfortunately, the name being declared is separated from the declaration
 7814: @c construct itself by a complicated syntactic structure---the ``declarator''.
 7815: 
 7816: 不幸にも、込み入った文法構造「宣言子(declarator)」によって、
 7817: 宣言された名前は、その宣言の構造自身から切り離されます。
 7818: 
 7819: @c As a result, the part of Bison parser for C needs to be duplicated, with
 7820: @c all the nonterminal names changed: once for parsing a declaration in which
 7821: @c a typedef name can be redefined, and once for parsing a declaration in
 7822: @c which that can't be done.  Here is a part of the duplication, with actions
 7823: @c omitted for brevity:
 7824: 
 7825: 結果として、C言語に対するBison構文解析器は、
 7826: すべての非終端記号の名前を変えて、二重化されました。
 7827: 第1は、@code{typedef}名が再定義されているかもしれない宣言を構文解析し、
 7828: 第2は、再定義が起こりえない宣言を構文解析します。
 7829: 二重化したものの一部分を、簡単にするためにアクションを省略して、示します。
 7830: 
 7831: @example
 7832: initdcl:
 7833:           declarator maybeasm '='
 7834:           init
 7835:         | declarator maybeasm
 7836:         ;
 7837: 
 7838: notype_initdcl:
 7839:           notype_declarator maybeasm '='
 7840:           init
 7841:         | notype_declarator maybeasm
 7842:         ;
 7843: @end example
 7844: 
 7845: @c @noindent
 7846: @c Here @code{initdcl} can redeclare a typedef name, but @code{notype_initdcl}
 7847: @c cannot.  The distinction between @code{declarator} and
 7848: @c @code{notype_declarator} is the same sort of thing.
 7849: 
 7850: ここで、@code{initdcl}は@code{typedef}名を再宣言できますが、
 7851: @code{notype_initdcl}は再宣言できません。
 7852: @code{declarator}と@code{notype_declarator}の違いも同様です。
 7853: 
 7854: @c There is some similarity between this technique and a lexical tie-in
 7855: @c (described next), in that information which alters the lexical analysis is
 7856: @c changed during parsing by other parts of the program.  The difference is
 7857: @c here the information is global, and is used for other purposes in the
 7858: @c program.  A true lexical tie-in has a special-purpose flag controlled by
 7859: @c the syntactic context.
 7860: 
 7861: 前述の技術と、後述の字句解析結び付きには、
 7862: 字句解析に影響する情報が入力の別の部分を構文解析しているときに
 7863: 変化させられるという、共通点があります。
 7864: 前者では、情報が広域的で、プログラム@footnote{【訳注】構文解析器。}の別の目的に
 7865: 使われることが異なります。
 7866: 本当の字句解析結び付きは、文脈によって制御される、
 7867: 特別の目的のフラグを持ちます。
 7868: 
 7869: 
 7870: @c =====================================================================
 7871: @node Lexical Tie-ins, Tie-in Recovery, Semantic Tokens, Context Dependency
 7872: @c @section Lexical Tie-ins
 7873: @section 字句解析結び付き
 7874: @cindex lexical tie-in
 7875: @cindex 字句解析結び付き
 7876: 
 7877: @c One way to handle context-dependency is the @dfn{lexical tie-in}: a flag
 7878: @c which is set by Bison actions, whose purpose is to alter the way tokens are
 7879: @c parsed.
 7880: 
 7881: 文脈依存性を処理する1つの方法は、@dfn{字句解析結び付き(lexical tie-in)}で、
 7882: Bisonのアクションによって設定されるフラグが、
 7883: トークンが構文解析される方法に影響します。
 7884: 
 7885: @c For example, suppose we have a language vaguely like C, but with a special
 7886: @c construct @samp{hex (@var{hex-expr})}.  After the keyword @code{hex} comes
 7887: @c an expression in parentheses in which all integers are hexadecimal.  In
 7888: @c particular, the token @samp{a1b} must be treated as an integer rather than
 7889: @c as an identifier if it appears in that context.  Here is how you can do it:
 7890: 
 7891: たとえば、C言語によく似ていて、@samp{hex (@var{hex-expr})}という
 7892: 特別な構造を持つ言語について、考えてみましょう。
 7893: 予約語@code{hex}がきた後にかっこで囲まれた式が続いて、
 7894: そのかっこの中ではすべての整数が16進数になります。
 7895: 特に、トークン@samp{a1b}は、このような文脈に現れれば、
 7896: 識別子ではなく整数として扱われる必要があります。
 7897: どのようにすればよいかを示します。
 7898: 
 7899: @example
 7900: @group
 7901: %@{
 7902: int hexflag;
 7903: %@}
 7904: %%
 7905: @dots{}
 7906: @end group
 7907: @group
 7908: expr:   IDENTIFIER
 7909:         | constant
 7910:         | HEX '('
 7911:                 @{ hexflag = 1; @}
 7912:           expr ')'
 7913:                 @{ hexflag = 0;
 7914:                    $$ = $4; @}
 7915:         | expr '+' expr
 7916:                 @{ $$ = make_sum ($1, $3); @}
 7917:         @dots{}
 7918:         ;
 7919: @end group
 7920: 
 7921: @group
 7922: constant:
 7923:           INTEGER
 7924:         | STRING
 7925:         ;
 7926: @end group
 7927: @end example
 7928: 
 7929: @c @noindent
 7930: @c Here we assume that @code{yylex} looks at the value of @code{hexflag}; when
 7931: @c it is nonzero, all integers are parsed in hexadecimal, and tokens starting
 7932: @c with letters are parsed as integers if possible.
 7933: 
 7934: @code{yylex}は、@code{hexflag}の値が0でなければ、
 7935: すべての整数が16進数であると字句解析し、
 7936: 英字で始まるトークンも可能な限り整数と解釈すると、仮定します。
 7937: 
 7938: @c The declaration of @code{hexflag} shown in the C declarations section of
 7939: @c the parser file is needed to make it accessible to the actions 
 7940: @c (@pxref{C Declarations, ,The C Declarations Section}).
 7941: @c You must also write the code in @code{yylex} to obey the flag.
 7942: 
 7943: @code{hexflag}の宣言は、アクションから参照可能なように、
 7944: 文法ファイルのC宣言部に書かれる必要があります
 7945: (@pxref{C Declarations, ,The C Declarations Section})。
 7946: 同様に、@code{yylex}のプログラムにも、@code{hexflag}の宣言が必要です。
 7947: 
 7948: 
 7949: @c =====================================================================
 7950: @node Tie-in Recovery,  , Lexical Tie-ins, Context Dependency
 7951: @c @section Lexical Tie-ins and Error Recovery
 7952: @section 字句解析結び付きとエラー回復
 7953: 
 7954: @c Lexical tie-ins make strict demands on any error recovery rules you have.
 7955: @c @xref{Error Recovery}.
 7956: 字句解析結び付きは、厳密なエラー回復規則を要求します。
 7957: @xref{Error Recovery}。
 7958: 
 7959: @c The reason for this is that the purpose of an error recovery rule is to
 7960: @c abort the parsing of one construct and resume in some larger construct.
 7961: @c For example, in C-like languages, a typical error recovery rule is to skip
 7962: @c tokens until the next semicolon, and then start a new statement, like this:
 7963: 
 7964: その理由は、エラー回復規則の目的が、ある構成物の構文解析を中断し、
 7965: より大きな構成物の構文解析を再開することです。
 7966: 前述のC言語に似ている言語の例では、次のように、
 7967: 標準的なエラー回復規則は、次のセミコロンまでトークンを読み捨て、
 7968: 新しい文の構文解析を再開します。
 7969: 
 7970: @example
 7971: stmt:   expr ';'
 7972:         | IF '(' expr ')' stmt @{ @dots{} @}
 7973:         @dots{}
 7974:         error ';'
 7975:                 @{ hexflag = 0; @}
 7976:         ;
 7977: @end example
 7978: 
 7979: @c If there is a syntax error in the middle of a @samp{hex (@var{expr})}
 7980: @c construct, this error rule will apply, and then the action for the
 7981: @c completed @samp{hex (@var{expr})} will never run.  So @code{hexflag} would
 7982: @c remain set for the entire rest of the input, or until the next @code{hex}
 7983: @c keyword, causing identifiers to be misinterpreted as integers.
 7984: 
 7985: もし、@samp{hex (@var{expr})}の途中で構文エラーが発生すれば、
 7986: このエラー回復規則が適用され、完了した@samp{hex @var{expr})}に対する
 7987: アクションは決して実行されません。
 7988: すると、@code{hexflag}は、入力の残りの間ずっと設定されたままでいるか、
 7989: 次の@code{hex}予約語の出現までそのままの状態でいて、
 7990: 識別子が16進整数と誤解されます。
 7991: 
 7992: @c To avoid this problem the error recovery rule itself clears @code{hexflag}.
 7993: 
 7994: この問題を防ぐためには、エラー回復規則が
 7995: @code{hexflag}を元に戻すべきです。
 7996: 
 7997: @c There may also be an error recovery rule that works within expressions.
 7998: @c For example, there could be a rule which applies within parentheses
 7999: @c and skips to the close-parenthesis:
 8000: 
 8001: さらに、式の内部で働くエラー回復規則があるかもしれません。
 8002: たとえば、次の例のように、かっこの中でエラーが発生すると、
 8003: 閉じかっこまで読み捨てるようなエラー回復規則が考えられます。
 8004: 
 8005: @example
 8006: @group
 8007: expr:   @dots{}
 8008:         | '(' expr ')'
 8009:                 @{ $$ = $2; @}
 8010:         | '(' error ')'
 8011:         @dots{}
 8012: @end group
 8013: @end example
 8014: 
 8015: @c If this rule acts within the @code{hex} construct, it is not going to abort
 8016: @c that construct (since it applies to an inner level of parentheses within
 8017: @c the construct).  Therefore, it should not clear the flag: the rest of
 8018: @c the @code{hex} construct should be parsed with the flag still in effect.
 8019: 
 8020: もし、この規則が@code{hex}構造の中で働くならば、
 8021: その構造の中の内側のかっこに適用されるので、
 8022: 構造を中断するべきではありません。
 8023: したがって、このアクションではフラグを戻すべきではなく、
 8024: @code{hex}構造の残りはフラグを有効にしたまま構文解析されるべきです。
 8025: 
 8026: @c What if there is an error recovery rule which might abort out of the
 8027: @c @code{hex} construct or might not, depending on circumstances?  There is no
 8028: @c way you can write the action to determine whether a @code{hex} construct is
 8029: @c being aborted or not.  So if you are using a lexical tie-in, you had better
 8030: @c make sure your error recovery rules are not of this kind.  Each rule must
 8031: @c be such that you can be sure that it always will, or always won't, have to
 8032: @c clear the flag.
 8033: 
 8034: 状況に応じて、@code{hex}構造を中断できるかもしれないし、そうでないかもしれない
 8035: エラー回復規則があれば、どうなるでしょうか。
 8036: @code{hex}構造を中断すべきかどうか決定できるアクションを書けません。
 8037: そこで、もし、字句解析結び付きを使っているならば、
 8038: あなたが書いたエラー回復規則がそのようになっていないことを確かめるべきです。
 8039: それぞれの規則は、常にフラグを戻すべきか、あるいは常にフラグを戻さないべきか、
 8040: 決定できるべきです。
 8041: 
 8042: 
 8043: @c =====================================================================
 8044: @node Debugging, Invocation, Context Dependency, Top
 8045: @c @chapter Debugging Your Parser
 8046: @chapter 構文解析器のデバッグ
 8047: @findex YYDEBUG
 8048: @findex yydebug
 8049: @cindex debugging
 8050: @cindex tracing the parser
 8051: @cindex 追跡, 構文解析器
 8052: @cindex 構文解析器の追跡
 8053: 
 8054: @c If a Bison grammar compiles properly but doesn't do what you want when it
 8055: @c runs, the @code{yydebug} parser-trace feature can help you figure out why.
 8056: 
 8057: もし、Bison文法ファイルが正しくコンパイルされたのに、
 8058: 生成された構文解析器が思いどおりに動かない場合には、
 8059: @code{yydebug}構文解析器追跡機能が、調査の役に立つでしょう。
 8060: 
 8061: @c To enable compilation of trace facilities, you must define the macro
 8062: @c @code{YYDEBUG} when you compile the parser.  You could use
 8063: @c @samp{-DYYDEBUG=1} as a compiler option or you could put @samp{#define
 8064: @c YYDEBUG 1} in the C declarations section of the grammar file 
 8065: @c (@pxref{C Declarations, ,The C Declarations Section}).
 8066: @c Alternatively, use the @samp{-t} option when
 8067: @c you run Bison (@pxref{Invocation, ,Invoking Bison}).
 8068: @c We always define @code{YYDEBUG} so that
 8069: @c debugging is always possible.
 8070: 
 8071: 追跡機能のコンパイルを有効にするためには、
 8072: 構文解析器をコンパイルするときに、マクロ@code{YYDEBUG}を定義する必要があります。
 8073: そのためには、コンパイラのオプションに@samp{-DYYDEBUG=1}を指定するか、
 8074: あるいは、文法ファイルのC宣言部に@samp{#define YYDEBUG 1}と書いておく
 8075: 必要があります(@pxref{C Declarations, ,The C Declarations Section})。
 8076: あるいは、Bisonを実行するときに(@pxref{Invocation, ,Invoking Bison})、
 8077: @samp{-t}オプションを指定しておくと、
 8078: @code{YYDEBUG}が定義され、追跡が可能になります。
 8079: 
 8080: @c The trace facility uses @code{stderr}, so you must add @w{@code{#include
 8081: @c <stdio.h>}} to the C declarations section unless it is already there.
 8082: 
 8083: 追跡機能は@code{stderr}を使うので、C宣言部に
 8084: @w{@code{#include <stdio.h>}}と書いておく必要があります。
 8085: 
 8086: @c Once you have compiled the program with trace facilities, the way to
 8087: @c request a trace is to store a nonzero value in the variable @code{yydebug}.
 8088: @c You can do this by making the C code do it (in @code{main}, perhaps), or
 8089: @c you can alter the value with a C debugger.
 8090: 
 8091: 追跡機能付で構文解析器をコンパイルしたら、構文解析器の実行時に、
 8092: 追跡機能を有効にするために、@code{yydebug}変数を0でない値にしてください。
 8093: C言語のプログラム(おそらく@code{main}関数の中)でこの変数に代入するか、
 8094: あるいは、デバッガでこの変数の値を変えればいいでしょう。
 8095: 
 8096: @c Each step taken by the parser when @code{yydebug} is nonzero produces a
 8097: @c line or two of trace information, written on @code{stderr}.  The trace
 8098: @c messages tell you these things:
 8099: 
 8100: @code{yydebug}が0でない場合、構文解析器はそれぞれの段階で、
 8101: 1行まはた2行の追跡情報を生成し、@code{stderr}に出力します。
 8102: 追跡情報には、次のような情報が含まれています。
 8103: 
 8104: @itemize @bullet
 8105: @item
 8106: @c Each time the parser calls @code{yylex}, what kind of token was read.
 8107: @c
 8108: 構文解析器が@code{yylex}を呼ぶたびに、
 8109: 読み込まれたトークンの種類が記録されます。
 8110: 
 8111: @item
 8112: @c Each time a token is shifted, the depth and complete contents of the
 8113: @c state stack (@pxref{Parser States}).
 8114: @c
 8115: トークンがシフトされるたびに、状態スタックの深さと完全な内容が
 8116: 表示されます(@pxref{Parser States})。
 8117: 
 8118: @item
 8119: @c Each time a rule is reduced, which rule it is, and the complete contents
 8120: @c of the state stack afterward.
 8121: @c
 8122: 規則が還元されるたびに、どの規則が使われるか、そして、
 8123: 還元後の状態スタックの完全な内容が記録されます。
 8124: 
 8125: @end itemize
 8126: 
 8127: @c To make sense of this information, it helps to refer to the listing file
 8128: @c produced by the Bison @samp{-v} option
 8129: @c (@pxref{Invocation, ,Invoking Bison})
 8130: @c This file
 8131: @c shows the meaning of each state in terms of positions in various rules, and
 8132: @c also what each state will do with each possible input token.  As you read
 8133: @c the successive trace messages, you can see that the parser is functioning
 8134: @c according to its specification in the listing file.  Eventually you will
 8135: @c arrive at the place where something undesirable happens, and you will see
 8136: @c which parts of the grammar are to blame.
 8137: 
 8138: この情報を理解するためには、Bisonに@samp{-v}オプション
 8139: (@pxref{Invocation, ,Invoking Bison})を付けて実行すると生成される
 8140: 明細ファイルが参考になるでしょう。
 8141: このファイルには、さまざまな規則の中での位置による表現で
 8142: 各状態の意味が示され、また、
 8143: 各状態がそれぞれの可能な入力トークンによって
 8144: どのように動作するかが示されています。
 8145: 連続する追跡の意味を読むことによって、
 8146: 明細ファイルで仕様が示されている構文解析器の機能について、理解できるでしょう。
 8147: 何か望ましくないことが起きている部分を確認すれば、
 8148: 文法ファイルのどこに問題があるかわかるでしょう。
 8149: 
 8150: @c The parser file is a C program and you can use C debuggers on it, but it's
 8151: @c not easy to interpret what it is doing.  The parser function is a
 8152: @c finite-state machine interpreter, and aside from the actions it executes
 8153: @c the same code over and over.  Only the values of variables show where in
 8154: @c the grammar it is working.
 8155: 
 8156: 構文解析器ファイルはC言語のプログラムなので、
 8157: Cのデバッガを使えますが、
 8158: 何が起きているか調べることは困難です。
 8159: 構文解析器関数は、有限状態機械インタープリタで、
 8160: アクションが実行されると、
 8161: プログラムの同じ部分が何度も何度も実行されます。
 8162: 実用的なのは文法の中で変数の値を調べることだけでしょう。
 8163: 
 8164: @findex YYPRINT
 8165: @c The debugging information normally gives the token type of each token
 8166: @c read, but not its semantic value.  You can optionally define a macro
 8167: @c named @code{YYPRINT} to provide a way to print the value.  If you define
 8168: @c @code{YYPRINT}, it should take three arguments.  The parser will pass a
 8169: @c standard I/O stream, the numeric code for the token type, and the token
 8170: @c value (from @code{yylval}).
 8171: 
 8172: デバッグ情報には、通常、それぞれのトークンのトークン型だけが含まれ、
 8173: トークンの意味値は含まれません。
 8174: マクロ@code{YYPRINT}を定義することで、
 8175: トークンの意味値を表示させられます。
 8176: @code{YYPRINT}の定義には、3個の引数がともないます。
 8177: 構文解析器は、@code{YYPRINT}に、標準入出力ストリーム、
 8178: トークン型の数値番号、トークンの値(@code{yylval}による)を渡します。
 8179: 
 8180: @c Here is an example of @code{YYPRINT} suitable for the multi-function
 8181: @c calculator (@pxref{Mfcalc Decl, ,Declarations for @code{mfcalc}}):
 8182: 
 8183: 多機能電卓に適する@code{YYPRINT}の例を示します
 8184: (@pxref{Mfcalc Decl, ,Declarations for @code{mfcalc}})。
 8185: 
 8186: @smallexample
 8187: #define YYPRINT(file, type, value)   yyprint (file, type, value)
 8188: 
 8189: static void
 8190: yyprint (file, type, value)
 8191:      FILE *file;
 8192:      int type;
 8193:      YYSTYPE value;
 8194: @{
 8195:   if (type == VAR)
 8196:     fprintf (file, " %s", value.tptr->name);
 8197:   else if (type == NUM)
 8198:     fprintf (file, " %d", value.val);
 8199: @}
 8200: @end smallexample
 8201: 
 8202: 
 8203: @c =====================================================================
 8204: @node Invocation, Table of Symbols, Debugging, Top
 8205: @c @chapter Invoking Bison
 8206: @chapter Bisonの実行
 8207: @cindex invoking Bison
 8208: @cindex Bison invocation
 8209: @cindex options for invoking Bison
 8210: @cindex Bisonの実行
 8211: @cindex 実行, Bison
 8212: @cindex Bison実行のオプション
 8213: @cindex オプション, Bison実行
 8214: 
 8215: @c The usual way to invoke Bison is as follows:
 8216: 
 8217: 通常、Bisonは次のように実行します。
 8218: 
 8219: @example
 8220: bison @var{infile}
 8221: @end example
 8222: 
 8223: @c Here @var{infile} is the grammar file name, which usually ends in
 8224: @c @samp{.y}.  The parser file's name is made by replacing the @samp{.y}
 8225: @c with @samp{.tab.c}.  Thus, the @samp{bison foo.y} filename yields
 8226: @c @file{foo.tab.c}, and the @samp{bison hack/foo.y} filename yields
 8227: @c @file{hack/foo.tab.c}.@refill
 8228: 
 8229: ここで、@var{infile}は文法ファイルで、名前が通常@samp{.y}で終わります。
 8230: 生成される構文解析器ファイルは、文法ファイルの名前の@samp{.y}を
 8231: @samp{.tab.c}に変えたものです。
 8232: したがって、@samp{bison foo.y}によって@samp{foo.tab.c}を得られますし、
 8233: @samp{bison hack/foo.y}によって@samp{hack/foo.tab.c}を得られます。
 8234: 
 8235: @menu
 8236: * Bison Options::     All the options described in detail, 
 8237: 			in alphabetical order by short options.
 8238: * Option Cross Key::  Alphabetical list of long options.
 8239: * VMS Invocation::    Bison command syntax on VMS.
 8240: @end menu
 8241: 
 8242: 
 8243: @c =====================================================================
 8244: @node Bison Options, Option Cross Key,  , Invocation
 8245: @c @section Bison Options
 8246: @section Bisonのオプション
 8247: 
 8248: @c Bison supports both traditional single-letter options and mnemonic long
 8249: @c option names.  Long option names are indicated with @samp{--} instead of
 8250: @c @samp{-}.  Abbreviations for option names are allowed as long as they
 8251: @c are unique.  When a long option takes an argument, like
 8252: @c @samp{--file-prefix}, connect the option name and the argument with
 8253: @c @samp{=}.
 8254: 
 8255: Bisonは、伝統的な1文字のオプションと、記憶しやすい長いオプション名の
 8256: 両方を受け付けます。長いオプション名は、@samp{-}の代わりに、
 8257: @samp{--}で指定します。
 8258: 一意性を失わない範囲で、長いオプション名を省略できます。
 8259: 長いオプションが引数をともなう場合、たとえば、@samp{--file-prefix}では、
 8260: オプション名と引数の間に@samp{=}を入れます。
 8261: 
 8262: @c Here is a list of options that can be used with Bison, alphabetized by
 8263: @c short option.  It is followed by a cross key alphabetized by long
 8264: @c option.
 8265: 
 8266: Bisonに対して指定可能なオプションの一覧を、アルファベット順に示します。
 8267: さらに、長い名前のアルファベット順の対応を示します。
 8268: 
 8269: @table @samp
 8270: @item -b @var{file-prefix}
 8271: @itemx --file-prefix=@var{prefix}
 8272: @c Specify a prefix to use for all Bison output file names.  The names are
 8273: @c chosen as if the input file were named @file{@var{prefix}.c}.
 8274: @c
 8275: Bisonが生成するすべてのファイルの名前の前半部分を指定します。
 8276: 入力される文法ファイルの名前が@file{@var{prefix}.y}であった場合と、
 8277: 同じ結果を得られます。
 8278: 
 8279: @item -d
 8280: @itemx --defines
 8281: @c Write an extra output file containing macro definitions for the token
 8282: @c type names defined in the grammar and the semantic value type
 8283: @c @code{YYSTYPE}, as well as a few @code{extern} variable declarations.
 8284: @c
 8285: 文法ファイル中で定義されたトークン型名に対するマクロ定義、
 8286: 意味値型@code{YYSTYPE}、いくつかの@code{extern}変数宣言を含む、
 8287: 追加の出力ファイルを生成します。
 8288: 
 8289: @c If the parser output file is named @file{@var{name}.c} then this file
 8290: @c is named @file{@var{name}.h}.@refill
 8291: 
 8292: 生成される構文解析ファイルの名前が@file{@var{name}.c}ならば、
 8293: このファイルの名前は@file{@var{name}.h}になります。
 8294: 
 8295: @c This output file is essential if you wish to put the definition of
 8296: @c @code{yylex} in a separate source file, because @code{yylex} needs to
 8297: @c be able to refer to token type codes and the variable
 8298: @c @code{yylval}.  @xref{Token Values, ,Semantic Values of Tokens}.@refill
 8299: 
 8300: @code{yylex}関数を独立なソースファイルの中で定義しているならば、
 8301: それはトークン型番号と変数@code{yylval}を必要とするので、
 8302: このファイルを@code{#include}する必要があります
 8303: @xref{Token Values, ,Semantic Values of Tokens}。
 8304: 
 8305: @item -l
 8306: @itemx --no-lines
 8307: @c Don't put any @code{#line} preprocessor commands in the parser file.
 8308: @c Ordinarily Bison puts them in the parser file so that the C compiler
 8309: @c and debuggers will associate errors with your source file, the
 8310: @c grammar file.  This option causes them to associate errors with the
 8311: @c parser file, treating it as an independent source file in its own right.
 8312: @c
 8313: 構文解析器ファイルの中に、@code{#line}プリプロセッサディレクティブを生成しません。
 8314: 通常、Bisonはこれを生成し、Cコンパイラとデバッガが、
 8315: 文法ファイルのどこでエラーが発生したかを見つけるために使います。
 8316: このオプションは、エラーと構文解析器の行番号を結び付け、
 8317: 構文解析器を独立なソースファイルとして扱います。
 8318: 
 8319: @item -n
 8320: @itemx --no-parser
 8321: @c Do not include any C code in the parser file; generate tables only.  The
 8322: @c parser file contains just @code{#define} directives and static variable
 8323: @c declarations.
 8324: @c
 8325: 構文解析器にCのプログラムを含めず、表だけを生成します。
 8326: 構文解析器ファイルは、@code{#define}ディレクティブと
 8327: 静的変数の宣言のみからなります。
 8328: 
 8329: @c This option also tells Bison to write the C code for the grammar actions
 8330: @c into a file named @file{@var{filename}.act}, in the form of a
 8331: @c brace-surrounded body fit for a @code{switch} statement.
 8332: 
 8333: このオプションにより、@file{@var{filename}.act}という名前のファイルに、
 8334: 文法アクションに対するC言語のプログラムが書かれます。
 8335: その書式は、@code{switch}文に対応するブレースで囲まれたブロックです。
 8336: 
 8337: @item -o @var{outfile}
 8338: @itemx --output-file=@var{outfile}
 8339: @c Specify the name @var{outfile} for the parser file.
 8340: @c
 8341: 生成される構文解析器ファイルの名前を指定します。
 8342: 
 8343: @c The other output files' names are constructed from @var{outfile}
 8344: @c as described under the @samp{-v} and @samp{-d} options.
 8345: 他の出力ファイルのファイル名の指定は
 8346: @samp{-v}と@samp{-d}オプションの項を参照してください。
 8347: 
 8348: @item -p @var{prefix}
 8349: @itemx --name-prefix=@var{prefix}
 8350: @c Rename the external symbols used in the parser so that they start with
 8351: @c @var{prefix} instead of @samp{yy}.  The precise list of symbols renamed
 8352: @c is @code{yyparse}, @code{yylex}, @code{yyerror}, @code{yynerrs},
 8353: @c @code{yylval}, @code{yychar} and @code{yydebug}.
 8354: @c
 8355: 構文解析器が使う外部名を@samp{yy}でなく@var{prefix}で始まるように変えます。
 8356: 影響を受ける名前は、
 8357: @code{yyparse}、@code{yylex}、@code{yyerror}、@code{yynerrs}、
 8358: @code{yylval}、@code{yychar}、@code{yydebug}です。
 8359: 
 8360: @c For example, if you use @samp{-p c}, the names become @code{cparse},
 8361: @c @code{clex}, and so on.
 8362: 
 8363: たとえば、@samp{-p c}オプションを指定すれば、
 8364: 名前は@code{cparse}、@code{clex}などになります。
 8365: 
 8366: @c @xref{Multiple Parsers, ,Multiple Parsers in the Same Program}.
 8367: 
 8368: @xref{Multiple Parsers, ,Multiple Parsers in the Same Program}。
 8369: 
 8370: @item -r
 8371: @itemx --raw
 8372: @c Pretend that @code{%raw} was specified.  @xref{Decl Summary}.
 8373: @c
 8374: @code{%raw}が指定されたように振る舞います。
 8375: @xref{Decl Summary}。
 8376: 
 8377: @item -t
 8378: @itemx --debug
 8379: @c Output a definition of the macro @code{YYDEBUG} into the parser file,
 8380: @c so that the debugging facilities are compiled.
 8381: @c @xref{Debugging, ,Debugging Your Parser}.
 8382: @c
 8383: デバッグ機能がコンパイルされるように、
 8384: マクロ@code{YYDEBUG}の定義を構文解析器ファイルに入れます
 8385: @xref{Debugging, ,Debugging Your Parser}。
 8386: 
 8387: @item -v
 8388: @itemx --verbose
 8389: @c Write an extra output file containing verbose descriptions of the
 8390: @c parser states and what is done for each type of look-ahead token in
 8391: @c that state.
 8392: @c
 8393: 構文解析器の状態についての詳細な説明と、
 8394: それらの状態でそれぞれの先読みトークンが現れると何が起きるか記述した、
 8395: 追加のファイルを生成します。
 8396: 
 8397: @c This file also describes all the conflicts, both those resolved by
 8398: @c operator precedence and the unresolved ones.
 8399: 
 8400: このファイルは、演算子の優先順位によって解決したものも解決しなかった
 8401: ものも含めて、衝突についての説明を含んでいます。
 8402: 
 8403: @c The file's name is made by removing @samp{.tab.c} or @samp{.c} from
 8404: @c the parser output file name, and adding @samp{.output} instead.@refill
 8405: 
 8406: 生成されるファイルの名前は、構文解析器のファイルの名前から、
 8407: @samp{.tab.c}または@samp{.c}を取り除いて、
 8408: 代わりに@samp{.output}を付けたものです。
 8409: 
 8410: @c Therefore, if the input file is @file{foo.y}, then the parser file is
 8411: @c called @file{foo.tab.c} by default.  As a consequence, the verbose
 8412: @c output file is called @file{foo.output}.@refill
 8413: 
 8414: したがって、入力の文法ファイルの名前が@file{foo.y}ならば、
 8415: 特に指定しないと、構文解析器ファイルの名前は@file{foo.tab.c}になり、
 8416: 詳細な説明のファイルの名前は@file{foo.output}になります。
 8417: 
 8418: @item -V
 8419: @itemx --version
 8420: @c Print the version number of Bison and exit.
 8421: @c
 8422: バージョン番号を表示して、Bisonを終了させます。
 8423: 
 8424: @item -h
 8425: @itemx --help
 8426: @c Print a summary of the command-line options to Bison and exit.
 8427: @c
 8428: コマンドラインオプションの要約を表示して、Bisonを終了させます。
 8429: 
 8430: @need 1750
 8431: @item -y
 8432: @itemx --yacc
 8433: @itemx --fixed-output-files
 8434: @c Equivalent to @samp{-o y.tab.c}; the parser output file is called
 8435: @c @file{y.tab.c}, and the other outputs are called @file{y.output} and
 8436: @c @file{y.tab.h}.  The purpose of this option is to imitate Yacc's output
 8437: @c file name conventions.  Thus, the following shell script can substitute
 8438: @c for Yacc:@refill
 8439: @c
 8440: @samp{-o y.tab.c}と等価です。構文解析器ファイルの名前は
 8441: @file{y.tab.c}になり、他の出力ファイルの名前は@file{y.output}と
 8442: @file{y.tab.h}になります。このオプションの目的は、
 8443: 出力ファイルの名前をYaccに合わせることです。
 8444: 次のシェルスクリプトは、Yaccの代用になります。
 8445: 
 8446: @example
 8447: bison -y $*
 8448: @end example
 8449: @end table
 8450: 
 8451: 
 8452: @c =====================================================================
 8453: @node Option Cross Key, VMS Invocation, Bison Options, Invocation
 8454: @c @section Option Cross Key
 8455: @section オプション対応表
 8456: 
 8457: @c Here is a list of options, alphabetized by long option, to help you find
 8458: @c the corresponding short option.
 8459: 
 8460: オプションを、長い名前のアルファベット順に一覧表記して、
 8461: 対応する1文字オプションを書きます。
 8462: 
 8463: @tex
 8464: \def\leaderfill{\leaders\hbox to 1em{\hss.\hss}\hfill}
 8465: 
 8466: {\tt
 8467: \line{ --debug \leaderfill -t}
 8468: \line{ --defines \leaderfill -d}
 8469: \line{ --file-prefix \leaderfill -b}
 8470: \line{ --fixed-output-files \leaderfill -y}
 8471: \line{ --help \leaderfill -h}
 8472: \line{ --name-prefix \leaderfill -p}
 8473: \line{ --no-lines \leaderfill -l}
 8474: \line{ --no-parser \leaderfill -n}
 8475: \line{ --output-file \leaderfill -o}
 8476: \line{ --raw \leaderfill -r}
 8477: \line{ --token-table \leaderfill -k}
 8478: \line{ --verbose \leaderfill -v}
 8479: \line{ --version \leaderfill -V}
 8480: \line{ --yacc \leaderfill -y}
 8481: }
 8482: @end tex
 8483: 
 8484: @ifinfo
 8485: @example
 8486: --debug                               -t
 8487: --defines                             -d
 8488: --file-prefix=@var{prefix}                  -b @var{file-prefix}
 8489: --fixed-output-files --yacc           -y
 8490: --help                                -h
 8491: --name-prefix=@var{prefix}                  -p @var{name-prefix}
 8492: --no-lines                            -l
 8493: --no-parser                           -n
 8494: --output-file=@var{outfile}                 -o @var{outfile}
 8495: --raw                                 -r			
 8496: --token-table                         -k
 8497: --verbose                             -v
 8498: --version                             -V
 8499: @end example
 8500: @end ifinfo
 8501: 
 8502: 
 8503: @c =====================================================================
 8504: @node VMS Invocation,  , Option Cross Key, Invocation
 8505: @c @section Invoking Bison under VMS
 8506: @section VMS上での実行
 8507: @cindex invoking Bison under VMS
 8508: @cindex VMS
 8509: @cindex 実行, VMS上
 8510: 
 8511: @c The command line syntax for Bison on VMS is a variant of the usual
 8512: @c Bison command syntax---adapted to fit VMS conventions.
 8513: 
 8514: VMS上のBisonのコマンドライン構文は、VMSの慣習に合わせて、
 8515: 他のシステム上のBisonのコマンドライン構文と異なっています。
 8516: 
 8517: @c To find the VMS equivalent for any Bison option, start with the long
 8518: @c option, and substitute a @samp{/} for the leading @samp{--}, and
 8519: @c substitute a @samp{_} for each @samp{-} in the name of the long option.
 8520: @c For example, the following invocation under VMS:
 8521: 
 8522: VMSでは、すべてのBisonのオプションについて、
 8523: @samp{--}の代わりに@samp{/}に続く長い名前のオプションを書き、
 8524: オプション名中の@samp{-}を@samp{_}に変えます。
 8525: VMS上での実行例を示します。
 8526: 
 8527: @example
 8528: bison /debug/name_prefix=bar foo.y
 8529: @end example
 8530: 
 8531: @c @noindent
 8532: @c is equivalent to the following command under POSIX.
 8533: 
 8534: これは、POSIX上での次のコマンドラインと等価です。
 8535: 
 8536: @example
 8537: bison --debug --name-prefix=bar foo.y
 8538: @end example
 8539: 
 8540: @c The VMS file system does not permit filenames such as
 8541: @c @file{foo.tab.c}.  In the above example, the output file
 8542: @c would instead be named @file{foo_tab.c}.
 8543: 
 8544: VMSファイルシステムでは、@file{foo.tab.c}のようなファイル名が許されないので、
 8545: 構文解析器の名前は、上記の例の場合には、@file{foo_tab.c}になります。
 8546: 
 8547: 
 8548: @c =====================================================================
 8549: @node Table of Symbols, Glossary, Invocation, Top
 8550: @c @appendix Bison Symbols
 8551: @appendix Bisonの記号一覧
 8552: @cindex Bison symbols, table of
 8553: @cindex symbols in Bison, table of
 8554: @cindex 記号一覧, Bison
 8555: @cindex Bisonの記号一覧
 8556: 
 8557: @table @code
 8558: @item error
 8559: @c A token name reserved for error recovery.  This token may be used in
 8560: @c grammar rules so as to allow the Bison parser to recognize an error in
 8561: @c the grammar without halting the process.  In effect, a sentence
 8562: @c containing an error may be recognized as valid.  On a parse error, the
 8563: @c token @code{error} becomes the current look-ahead token.  Actions
 8564: @c corresponding to @code{error} are then executed, and the look-ahead
 8565: @c token is reset to the token that originally caused the violation.
 8566: @c @xref{Error Recovery}.
 8567: @c
 8568: エラー回復のために予約されているトークン名です。
 8569: このトークンが文法規則の中で使われていると、Bison構文解析器は、
 8570: 構文エラーを認識し、プロセスの実行を中断しません。
 8571: 実質的には、エラーを含む文が、有効であると認識されます。
 8572: エラーが起きると、@code{error}トークンが現在の先読みトークンになります。
 8573: @code{error}に対応するアクションが実行されて、
 8574: 先読みトークンがエラーの原因になったトークンに戻されます。
 8575: @xref{Error Recovery}。
 8576: 
 8577: @item YYABORT
 8578: @c Macro to pretend that an unrecoverable syntax error has occurred, by
 8579: @c making @code{yyparse} return 1 immediately.  The error reporting
 8580: @c function @code{yyerror} is not called.
 8581: @c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
 8582: @c
 8583: 回復不可能な構文エラーが発生した場合のためのマクロで、
 8584: 実行するとただちに@code{yyparse}が1を返します。
 8585: エラー報告関数@code{yyerror}は呼び出されません。
 8586: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 8587: 
 8588: @item YYACCEPT
 8589: @c Macro to pretend that a complete utterance of the language has been
 8590: @c read, by making @code{yyparse} return 0 immediately.  
 8591: @c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
 8592: @c
 8593: 構文解析器が言語を完全に読み終えた場合のためのマクロで、
 8594: 実行するとただちに@code{yyparse}が0を返します。
 8595: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 8596: 
 8597: @item YYBACKUP
 8598: @c Macro to discard a value from the parser stack and fake a look-ahead
 8599: @c token.
 8600: @c @xref{Action Features, ,Special Features for Use in Actions}.
 8601: @c
 8602: 構文解析器のスタックから1個の値を捨て、先読みトークンのふりをさせます。
 8603: @xref{Action Features, ,Special Features for Use in Actions}。
 8604: 
 8605: @item YYERROR
 8606: @c Macro to pretend that a syntax error has just been detected: call
 8607: @c @code{yyerror} and then perform normal error recovery if possible
 8608: @c (@pxref{Error Recovery}), or (if recovery is impossible) make
 8609: @c @code{yyparse} return 1.
 8610: @c @xref{Error Recovery}.
 8611: @c
 8612: 構文エラーがちょうど検出された場合のためのマクロで、
 8613: @code{yyerror}を呼び、可能ならば通常のエラー回復処理
 8614: (@pxref{Error Recovery})を実行し、不可能ならば
 8615: @code{yyparse}が1を返します。
 8616: @xref{Error Recovery}。
 8617: 
 8618: @item YYERROR_VERBOSE
 8619: @c Macro that you define with @code{#define} in the Bison declarations
 8620: @c section to request verbose, specific error message strings when
 8621: @c @code{yyerror} is called.
 8622: Bison宣言部で@code{#define}によってこのマクロを定義すると、
 8623: @code{yyerror}が呼ばれたときに表示されるエラー報告が詳しくなります。
 8624: 
 8625: @item YYINITDEPTH
 8626: @c Macro for specifying the initial size of the parser stack.
 8627: @c @xref{Stack Overflow}.
 8628: @c
 8629: 構文解析器スタックの最初の大きさを指定するマクロです。
 8630: @xref{Stack Overflow}。
 8631: 
 8632: @item YYLEX_PARAM
 8633: @c Macro for specifying an extra argument (or list of extra arguments) for
 8634: @c @code{yyparse} to pass to @code{yylex}.
 8635: @c @xref{Pure Calling,, Calling Conventions for Pure Parsers}.
 8636: @c
 8637: @code{yyparse}が@code{yylex}に渡すための、追加の引数または
 8638: 引数の並びを指定するためのマクロです。
 8639: @xref{Pure Calling,, Calling Conventions for Pure Parsers}。
 8640: 
 8641: @item YYLTYPE
 8642: @c Macro for the data type of @code{yylloc}; a structure with four
 8643: @c members.
 8644: @c @xref{Token Positions, ,Textual Positions of Tokens}.
 8645: @c
 8646: @code{yyloc}のデータ型を示すマクロで、4個のメンバからなる構造体です。
 8647: @xref{Token Positions, ,Textual Positions of Tokens}。
 8648: 
 8649: @item yyltype
 8650: @c Default value for YYLTYPE.
 8651: @c
 8652: @code{YYLTYPE}の省略時の値です。
 8653: 
 8654: @item YYMAXDEPTH
 8655: @c Macro for specifying the maximum size of the parser stack.
 8656: @c @xref{Stack Overflow}.
 8657: @c
 8658: 構文解析器のスタックの最大の大きさを指定するマクロです。
 8659: @xref{Stack Overflow}。
 8660: 
 8661: @item YYPARSE_PARAM
 8662: @c Macro for specifying the name of a parameter that @code{yyparse} should
 8663: @c accept.
 8664: @c @xref{Pure Calling,, Calling Conventions for Pure Parsers}.
 8665: @c
 8666: @code{yyparse}が受け取るべき引数の名前を指定するマクロです。
 8667: @xref{Pure Calling,, Calling Conventions for Pure Parsers}。
 8668: 
 8669: @item YYRECOVERING
 8670: @c Macro whose value indicates whether the parser is recovering from a
 8671: @c syntax error.
 8672: @c @xref{Action Features, ,Special Features for Use in Actions}.
 8673: @c
 8674: 構文解析器が構文エラーから回復している途中かどうかを示す値のマクロです。
 8675: @xref{Action Features, ,Special Features for Use in Actions}。
 8676: 
 8677: @item YYSTYPE
 8678: @c Macro for the data type of semantic values; @code{int} by default.
 8679: @c @xref{Value Type, ,Data Types of Semantic Values}.
 8680: @c
 8681: 意味値のデータ型を指定するためのマクロで、省略すると@code{int}になります。
 8682: @xref{Value Type, ,Data Types of Semantic Values}。
 8683: 
 8684: @item yychar
 8685: @c External integer variable that contains the integer value of the
 8686: @c current look-ahead token.  (In a pure parser, it is a local variable
 8687: @c within @code{yyparse}.)  Error-recovery rule actions may examine this
 8688: @c variable.
 8689: @c @xref{Action Features, ,Special Features for Use in Actions}.
 8690: @c
 8691: 広域的な@code{int}型の変数で、現在の先読みトークンの番号を記憶しています
 8692: (再入可能な構文解析器では、この変数は@code{yyparse}に局所的です)。
 8693: エラー回復規則のアクションは、この変数の値を調べられます。
 8694: @xref{Action Features, ,Special Features for Use in Actions}。
 8695: 
 8696: @item yyclearin
 8697: @c Macro used in error-recovery rule actions.  It clears the previous
 8698: @c look-ahead token.
 8699: @c @xref{Error Recovery}.
 8700: @c
 8701: エラー回復規則のアクションで使われるマクロです。
 8702: 直前の先読みトークンを消去します。
 8703: @xref{Error Recovery}。
 8704: 
 8705: @item yydebug
 8706: @c External integer variable set to zero by default.  If @code{yydebug}
 8707: @c is given a nonzero value, the parser will output information on input
 8708: @c symbols and parser action.
 8709: @c @xref{Debugging, ,Debugging Your Parser}.
 8710: @c
 8711: @code{int}型の広域変数で、初期値は0です。
 8712: @code{yydebug}の値が0でないと、構文解析器は、
 8713: 読み込んだ記号と構文解析器のアクションに関する情報を表示します。
 8714: @xref{Debugging, ,Debugging Your Parser}。
 8715: 
 8716: @item yyerrok
 8717: @c Macro to cause parser to recover immediately to its normal mode
 8718: @c after a parse error.
 8719: @c @xref{Error Recovery}.
 8720: @c
 8721: 構文エラーの後で、構文解析器をただちに通常の状態に戻すためのマクロです。
 8722: @xref{Error Recovery}。
 8723: 
 8724: @item yyerror
 8725: @c User-supplied function to be called by @code{yyparse} on error.  The
 8726: @c function receives one argument, a pointer to a character string
 8727: @c containing an error message.
 8728: @c @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
 8729: @c
 8730: エラーが起きたときに@code{yyparse}から呼び出される、ユーザー定義関数です。
 8731: この関数は1個の引数を受け取り、その引数はエラーの報告を含む文字列への
 8732: ポインタです。
 8733: @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}。
 8734: 
 8735: @item yylex
 8736: @c User-supplied lexical analyzer function, called with no arguments
 8737: @c to get the next token.
 8738: @c @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}.
 8739: @c 
 8740: ユーザー定義の字句解析関数で、次のトークンを得るために、
 8741: 引数なしで呼び出されます。
 8742: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 8743: 
 8744: @item yylval
 8745: @c External variable in which @code{yylex} should place the semantic
 8746: @c value associated with a token.  (In a pure parser, it is a local
 8747: @c variable within @code{yyparse}, and its address is passed to
 8748: @c @code{yylex}.)
 8749: @c @xref{Token Values, ,Semantic Values of Tokens}.
 8750: @c
 8751: トークンに関連する意味値を@code{yylex}が置くための広域変数です
 8752: (再入可能な構文解析器では、これは@code{yyparse}の局所変数で、
 8753: その番地が@code{yylex}に渡されます)。
 8754: @xref{Token Values, ,Semantic Values of Tokens}。
 8755: 
 8756: @item yylloc
 8757: @c External variable in which @code{yylex} should place the line and
 8758: @c column numbers associated with a token.  (In a pure parser, it is a
 8759: @c local variable within @code{yyparse}, and its address is passed to
 8760: @c @code{yylex}.)  You can ignore this variable if you don't use the
 8761: @c @samp{@@} feature in the grammar actions.
 8762: @c @xref{Token Positions, ,Textual Positions of Tokens}.
 8763: @c
 8764: トークンに関連する行番号と桁番号を@code{yylex}が置くための
 8765: 広域変数です(再入可能な構文解析器では、この変数は@code{yyparse}に
 8766: 局所的で、その番地が@code{yylex}に渡されます)。
 8767: 文法アクションで@samp{@@}機能を使わないならば、
 8768: この値を無視してかまいません。
 8769: @xref{Token Positions, ,Textual Positions of Tokens}。
 8770: 
 8771: @item yynerrs
 8772: @c Global variable which Bison increments each time there is a parse
 8773: @c error.  (In a pure parser, it is a local variable within
 8774: @c @code{yyparse}.)
 8775: @c @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}.
 8776: @c
 8777: 構文エラーが発生するたびにBisonが値を1増やす広域変数です
 8778: (再入可能な構文解析器では、この変数は@code{yyparse}に局所的です)。
 8779: @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}。
 8780: 
 8781: @item yyparse
 8782: @c The parser function produced by Bison; call this function to start
 8783: @c parsing.
 8784: @c @xref{Parser Function, ,The Parser Function @code{yyparse}}.
 8785: @c
 8786: Bisonによって生成される構文解析器関数で、
 8787: この関数を呼び出すことによって構文解析が始まります。
 8788: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 8789: 
 8790: @item %left
 8791: @c Bison declaration to assign left associativity to token(s).
 8792: @c @xref{Precedence Decl, ,Operator Precedence}.
 8793: @c
 8794: トークンに左結合性を与えるBison宣言です。
 8795: @xref{Precedence Decl, ,Operator Precedence}。
 8796: 
 8797: @item %no_lines
 8798: @c Bison declaration to avoid generating @code{#line} directives in the
 8799: @c parser file.
 8800: @c @xref{Decl Summary}.
 8801: @c
 8802: 構文解析器ファイルの中に@code{#line}ディレクティブを生成しないための
 8803: Bison宣言です。
 8804: @xref{Decl Summary}。
 8805: 
 8806: @item %nonassoc
 8807: @c Bison declaration to assign nonassociativity to token(s).
 8808: @c @xref{Precedence Decl, ,Operator Precedence}.
 8809: @c
 8810: トークンに非結合性を与えるためのBison宣言です。
 8811: @xref{Precedence Decl, ,Operator Precedence}。
 8812: 
 8813: @item %prec
 8814: @c Bison declaration to assign a precedence to a specific rule.
 8815: @c @xref{Contextual Precedence, ,Context-Dependent Precedence}.
 8816: @c
 8817: 指定された規則に優先順位を与えるためのBison宣言です。
 8818: @xref{Contextual Precedence, ,Context-Dependent Precedence}。
 8819: 
 8820: @item %pure_parser
 8821: @c Bison declaration to request a pure (reentrant) parser.
 8822: @c @xref{Pure Decl, ,A Pure (Reentrant) Parser}.
 8823: @c
 8824: 再入可能な構文解析器を生成するためのBison宣言です。
 8825: @xref{Pure Decl, ,A Pure (Reentrant) Parser}。
 8826: 
 8827: @item %raw
 8828: @c Bison declaration to use Bison internal token code numbers in token
 8829: @c tables instead of the usual Yacc-compatible token code numbers.
 8830: @c @xref{Decl Summary}.
 8831: @c
 8832: 通常のYacc互換トークン番号の代わりに、
 8833: トークン表のBison内部トークン番号を使うための、Bison宣言です。
 8834: @xref{Decl Summary}。
 8835: 
 8836: @item %right
 8837: @c Bison declaration to assign right associativity to token(s).
 8838: @c @xref{Precedence Decl, ,Operator Precedence}.
 8839: @c
 8840: トークンに右結合性を与えるためのBison宣言です。
 8841: @xref{Precedence Decl, ,Operator Precedence}。
 8842: 
 8843: @item %start
 8844: @c Bison declaration to specify the start symbol.
 8845: @c @xref{Start Decl, ,The Start-Symbol}.
 8846: @c
 8847: 開始記号を指定するためのBison宣言です。
 8848: @xref{Start Decl, ,The Start-Symbol}。
 8849: 
 8850: @item %token
 8851: @c Bison declaration to declare token(s) without specifying precedence.
 8852: @c @xref{Token Decl, ,Token Type Names}.
 8853: @c
 8854: 優先順位を指定せずにトークンを宣言するためのBison宣言です。
 8855: @xref{Token Decl, ,Token Type Names}。
 8856: 
 8857: @item %token_table
 8858: @c Bison declaration to include a token name table in the parser file.
 8859: @c @xref{Decl Summary}.
 8860: @c
 8861: 構文解析器ファイルの中でトークン名の表を挿入するためのBison宣言です。
 8862: @xref{Decl Summary}。
 8863: 
 8864: @item %type
 8865: @c Bison declaration to declare nonterminals.
 8866: @c @xref{Type Decl, ,Nonterminal Symbols}.
 8867: @c
 8868: 非終端記号を宣言するためのBison宣言です。
 8869: @xref{Type Decl, ,Nonterminal Symbols}。
 8870: 
 8871: @item %union
 8872: @c Bison declaration to specify several possible data types for semantic
 8873: @c values.
 8874: @c @xref{Union Decl, ,The Collection of Value Types}.
 8875: @c
 8876: 意味値として可能ないくつかのデータ型を指定するためのBison宣言です。
 8877: @xref{Union Decl, ,The Collection of Value Types}.
 8878: @end table
 8879: 
 8880: @c These are the punctuation and delimiters used in Bison input:
 8881: 
 8882: Bison文法ファイルの中で使う、区切り記号があります。
 8883: 
 8884: @table @samp
 8885: @item %%
 8886: @c Delimiter used to separate the grammar rule section from the
 8887: @c Bison declarations section or the additional C code section.
 8888: @c @xref{Grammar Layout, ,The Overall Layout of a Bison Grammar}.
 8889: @c
 8890: Bison宣言部、文法規則部、(省略可能な)Cプログラム部を区切る記号です。
 8891: @xref{Grammar Layout, ,The Overall Layout of a Bison Grammar}。
 8892: 
 8893: @item %@{ %@}
 8894: @c All code listed between @samp{%@{} and @samp{%@}} is copied directly
 8895: @c to the output file uninterpreted.  Such code forms the ``C
 8896: @c declarations'' section of the input file.
 8897: @c @xref{Grammar Outline, ,Outline of a Bison Grammar}.
 8898: @c
 8899: 文法ファイルの@samp{%@{}と@samp{%@}}の間に書かれたすべてのプログラムは、
 8900: そのまま構文解析器ファイルに複写されます。
 8901: このようなプログラムが、文法ファイルのC宣言部を構成します。
 8902: @xref{Grammar Outline, ,Outline of a Bison Grammar}。
 8903: 
 8904: @item /*@dots{}*/
 8905: @c Comment delimiters, as in C.
 8906: @c
 8907: C言語と同様のコメントです。
 8908: 
 8909: @item :
 8910: @c Separates a rule's result from its components.
 8911: @c @xref{Rules, ,Syntax of Grammar Rules}.
 8912: 規則の結果と構成要素を分離する記号です。
 8913: @xref{Rules, ,Syntax of Grammar Rules}。
 8914: 
 8915: @item ;
 8916: @c Terminates a rule.
 8917: @c @xref{Rules, ,Syntax of Grammar Rules}.
 8918: @c
 8919: 規則の終わりの記号です。
 8920: @xref{Rules, ,Syntax of Grammar Rules}。
 8921: 
 8922: @item |
 8923: @c Separates alternate rules for the same result nonterminal.
 8924: @c @xref{Rules, ,Syntax of Grammar Rules}.
 8925: @c
 8926: 同一の非終端記号を結果とする複数の規則を区切る記号です。
 8927: @xref{Rules, ,Syntax of Grammar Rules}。
 8928: @end table
 8929: 
 8930: 
 8931: @c =====================================================================
 8932: @node Glossary, Index, Table of Symbols, Top
 8933: @c @appendix Glossary
 8934: @appendix 用語集
 8935: @cindex glossary
 8936: @cindex 用語集
 8937: 
 8938: @table @asis
 8939: @c @item Backus-Naur Form (BNF)
 8940: @item Backus-Naur Form(BNF)(バッカス-ナウア記法)
 8941: @c Formal method of specifying context-free grammars.  BNF was first used
 8942: @c in the @cite{ALGOL-60} report, 1963.
 8943: @c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
 8944: @c
 8945: 文脈自由文法を形式的に表現する方法です。
 8946: BNFは、1963年の報告@cite{ALGOL-60}で初めて使われました。
 8947: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 8948: 
 8949: @c @item Context-free grammars
 8950: @item Context-free grammars(文脈自由文法)
 8951: @c Grammars specified as rules that can be applied regardless of context.
 8952: @c Thus, if there is a rule which says that an integer can be used as an
 8953: @c expression, integers are allowed @emph{anywhere} an expression is
 8954: @c permitted.
 8955: @c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
 8956: @c
 8957: 文脈に関係なく適用される規則によって定められる文法です。
 8958: したがって、もし、整数は式として使われてもよいという規則があれば、
 8959: 式が許される@emph{あらゆる場所で}整数の利用が許されます。
 8960: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 8961: 
 8962: @c @item Dynamic allocation
 8963: @item Dynamic allocation(動的割り当て)
 8964: @c Allocation of memory that occurs during execution, rather than at
 8965: @c compile time or on entry to a function.
 8966: @c
 8967: プログラムをコンパイルするときでも、関数の実行を始めるときでもなく、
 8968: 実行の途中でメモリを割り当てることです。
 8969: 
 8970: @c @item Empty string
 8971: @item Empty string(空文字列)
 8972: @c Analogous to the empty set in set theory, the empty string is a
 8973: @c character string of length zero.
 8974: @c
 8975: 集合論での空集合と同様に、空文字列とは長さが0の文字列です。
 8976: 
 8977: @c @item Finite-state stack machine
 8978: @item Finite-state stack machine(有限状態スタック機械)
 8979: @c A ``machine'' that has discrete states in which it is said to exist at
 8980: @c each instant in time.  As input to the machine is processed, the
 8981: @c machine moves from state to state as specified by the logic of the
 8982: @c machine.  In the case of the parser, the input is the language being
 8983: @c parsed, and the states correspond to various stages in the grammar
 8984: @c rules.
 8985: @c @xref{Algorithm, ,The Bison Parser Algorithm }.
 8986: @c
 8987: その完全な状態が、各瞬間での状態で記述される「機械」です。
 8988: 機械への入力が処理されると、機械の論理に応じて、
 8989: 機械の状態が別の状態に変わります。
 8990: 本書では、入力とは構文解析されている言語で、
 8991: 状態とは文法規則のさまざまな段階です。
 8992: @xref{Algorithm, ,The Bison Parser Algorithm }。
 8993: 
 8994: @c @item Grouping
 8995: @item Grouping(グループ)
 8996: @c A language construct that is (in general) grammatically divisible;
 8997: @c for example, `expression' or `declaration' in C.  
 8998: @c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
 8999: @c
 9000: 言語の構成要素で、(一般的に)文法的に分割可能なのもです。
 9001: たとえば、C言語の「式」や「宣言」です。
 9002: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 9003: 
 9004: @c @item Infix operator
 9005: @item Infix operator(中間記法演算子)
 9006: @c An arithmetic operator that is placed between the operands on which it
 9007: @c performs some operation.
 9008: @c
 9009: 演算の対象となるオペランドの中間に置かれる算術演算子です。
 9010: 
 9011: @c @item Input stream
 9012: @item Input stream(入力ストリーム)
 9013: @c A continuous flow of data between devices or programs.
 9014: @c
 9015: 入出力装置またはプログラムの間での、連続的なデータの流れです。
 9016: 
 9017: @c @item Language construct
 9018: @item Language construct(言語構文)
 9019: @c One of the typical usage schemas of the language.  For example, one of
 9020: @c the constructs of the C language is the @code{if} statement.
 9021: @c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
 9022: @c
 9023: 言語の概要を示す典型的な方法の1つです。
 9024: たとえば、C言語の構文の1つは@code{if}文です。
 9025: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 9026: 
 9027: @c @item Left associativity
 9028: @item Left associativity(左結合性)
 9029: @c Operators having left associativity are analyzed from left to right:
 9030: @c @samp{a+b+c} first computes @samp{a+b} and then combines with
 9031: @c @samp{c}.
 9032: @c @xref{Precedence, ,Operator Precedence}.
 9033: @c
 9034: 左結合性を持つ演算子は、左から右に向かって構文解析されます。
 9035: たとえば、@samp{a+b+c}では、まず@samp{a+b}が計算され、
 9036: 次に@samp{c}との和が計算されます。
 9037: @xref{Precedence, ,Operator Precedence}。
 9038: 
 9039: @c @item Left recursion
 9040: @item Left recursion(左再帰)
 9041: @c A rule whose result symbol is also its first component symbol;
 9042: @c for example, @samp{expseq1 : expseq1 ',' exp;}.
 9043: @c @xref{Recursion, ,Recursive Rules}.
 9044: @c
 9045: 結果の記号が構成要素の最初の記号と等しいような規則です。
 9046: たとえば、@samp{expseq1 : expseq1 ',' exp;}が左再帰です。
 9047: @xref{Recursion, ,Recursive Rules}。
 9048: 
 9049: @c @item Left-to-right parsing
 9050: @item Left-to-right parsing(LR構文解析)
 9051: @c Parsing a sentence of a language by analyzing it token by token from
 9052: @c left to right.
 9053: @c @xref{Algorithm, ,The Bison Parser Algorithm }.
 9054: @c
 9055: 左側から右側に向かって、トークンを次々に解析していくような、
 9056: 言語の構文解析方法です。
 9057: @xref{Algorithm, ,The Bison Parser Algorithm }。
 9058: 
 9059: @c @item Lexical analyzer (scanner)
 9060: @item Lexical analyzer(scanner)(字句解析器)
 9061: @c A function that reads an input stream and returns tokens one by one.
 9062: @c @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}.
 9063: @c
 9064: 入力ストリームを読んで、トークンを1つずつ返す関数です。
 9065: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 9066: 
 9067: @c @item Lexical tie-in
 9068: @item Lexical tie-in(字句解析結び付き)
 9069: @c A flag, set by actions in the grammar rules, which alters the way
 9070: @c tokens are parsed.
 9071: 文法規則によって設定されるフラグが、トークンが字句解析される方法に
 9072: 影響することです。
 9073: @c @xref{Lexical Tie-ins}.
 9074: @xref{Lexical Tie-ins}。
 9075: 
 9076: @c @item Literal string token
 9077: @item Literal string token(リテラル文字列トークン)
 9078: @c A token which constists of two or more fixed characters.
 9079: @c @xref{Symbols}.
 9080: @c
 9081: 2文字以上の決まった文字列からなるトークンです。
 9082: @xref{Symbols}。
 9083: 
 9084: @c @item Look-ahead token
 9085: @item Look-ahead token(先読みトークン)
 9086: @c A token already read but not yet shifted.
 9087: @c @xref{Look-Ahead, ,Look-Ahead Tokens}.
 9088: @c
 9089: すでに読み込まれていて、シフトされていないトークンです。
 9090: @xref{Look-Ahead, ,Look-Ahead Tokens}。
 9091: 
 9092: @item LALR(1)
 9093: @c The class of context-free grammars that Bison (like most other parser
 9094: @c generators) can handle; a subset of LR(1).
 9095: @c @xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}.
 9096: @c
 9097: Bison(または似ているほとんどの構文解析器)によって扱える、
 9098: 文脈自由文法の一部分で、LR(1)の部分集合です。
 9099: @xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}。
 9100: 
 9101: @item LR(1)
 9102: @c The class of context-free grammars in which at most one token of
 9103: @c look-ahead is needed to disambiguate the parsing of any piece of input.
 9104: @c
 9105: 任意の入力のあいまいでない構文解析に対して、
 9106: 単に1個の先読みトークンを必要とするような、
 9107: 文脈自由文法の一部分です。
 9108: 
 9109: @c @item Nonterminal symbol
 9110: @item Nonterminal symbol(非終端記号)
 9111: @c A grammar symbol standing for a grammatical construct that can
 9112: @c be expressed through rules in terms of smaller constructs; in other
 9113: @c words, a construct that is not a token.
 9114: @c @xref{Symbols}.
 9115: @c
 9116: 文法的構成要素を表す文法記号で、文法規則によってより小さな構成要素に
 9117: 分解できるものです。言い換えると、トークンでない構成要素です。
 9118: @xref{Symbols}。
 9119: 
 9120: @c @item Parse error
 9121: @item Parse error(構文エラー)
 9122: @c An error encountered during parsing of an input stream due to invalid
 9123: @c syntax.
 9124: @c @xref{Error Recovery}.
 9125: @c
 9126: 入力ストリームを構文解析しているときに、誤った文法によって発生するエラーです。
 9127: @xref{Error Recovery}。
 9128: 
 9129: @item Parser(構文解析器)
 9130: @c A function that recognizes valid sentences of a language by analyzing
 9131: @c the syntax structure of a set of tokens passed to it from a lexical
 9132: @c analyzer.
 9133: 字句解析器から渡されたトークンの集合の文法的構造を解析して、
 9134: 言語の有効な文を認識する関数です。
 9135: 
 9136: @c @item Postfix operator
 9137: @item Postfix operator(後置演算子)
 9138: @c An arithmetic operator that is placed after the operands upon which it
 9139: @c performs some operation.
 9140: 演算の対象のオペランドの後に置かれる算術演算子です。
 9141: 
 9142: @c @item Reduction
 9143: @item Reduction(還元)
 9144: @c Replacing a string of nonterminals and/or terminals with a single
 9145: @c nonterminal, according to a grammar rule.
 9146: @c @xref{Algorithm, ,The Bison Parser Algorithm }.
 9147: @c
 9148: 文法規則に従って、非終端記号または終端記号の列を、
 9149: 1個の非終端記号に置き換えることです。
 9150: @xref{Algorithm, ,The Bison Parser Algorithm }。
 9151: 
 9152: @c @item Reentrant
 9153: @item Reentrant(再入可能)
 9154: @c A reentrant subprogram is a subprogram which can be in invoked any
 9155: @c number of times in parallel, without interference between the various
 9156: @c invocations.
 9157: @c @xref{Pure Decl, ,A Pure (Reentrant) Parser}.
 9158: @c
 9159: 再入可能な手続きとは、複数の呼び出しの間での相互作用なしに、
 9160: 並行して任意の数を呼び出せる手続きです。
 9161: @footnote{【訳注】ある関数が終了する前に、
 9162: その同じ関数を非同期に呼び出してもよいということ。}
 9163: @xref{Pure Decl, ,A Pure (Reentrant) Parser}。
 9164: 
 9165: @c @item Reverse polish notation
 9166: @item Reverse polish notation(逆ポーランド記法)
 9167: @c A language in which all operators are postfix operators.
 9168: すべての演算子が後置記法演算子であるような言語です。
 9169: 
 9170: @c @item Right recursion
 9171: @item Right recursion(右再帰)
 9172: @c A rule whose result symbol is also its last component symbol;
 9173: @c for example, @samp{expseq1: exp ',' expseq1;}.
 9174: @c @xref{Recursion, ,Recursive Rules}.
 9175: @c
 9176: 規則の結果の記号が、規則の最後の構成要素と同じ記号であるような規則です。
 9177: たとえば、@samp{expseq1: exp ',' expseq1;}は右再帰です。
 9178: @xref{Recursion, ,Recursive Rules}.
 9179: 
 9180: @c @item Semantics
 9181: @item Semantics(意味)
 9182: @c In computer languages, the semantics are specified by the actions
 9183: @c taken for each instance of the language, i.e., the meaning of
 9184: @c each statement.
 9185: @c @xref{Semantics, ,Defining Language Semantics}.
 9186: @c
 9187: 計算機言語では、言語の各インスタンスが起こすアクションによって、
 9188: 意味が指定されます。すなわち、各文の意味です。
 9189: @xref{Semantics, ,Defining Language Semantics}。
 9190: 
 9191: @c @item Shift
 9192: @item Shift(シフト)
 9193: @c A parser is said to shift when it makes the choice of analyzing
 9194: @c further input from the stream rather than reducing immediately some
 9195: @c already-recognized rule.
 9196: @c @xref{Algorithm, ,The Bison Parser Algorithm }.
 9197: @c
 9198: 構文解析器がシフトするとは、
 9199: すでに認識されているある規則によってただちに還元する代わりに、
 9200: ストリームからのさらなる入力を分析することです。
 9201: @xref{Algorithm, ,The Bison Parser Algorithm }。
 9202: 
 9203: @c @item Single-character literal
 9204: @item Single-character literal(1文字リテラル)
 9205: @c A single character that is recognized and interpreted as is.
 9206: @c @xref{Grammar in Bison, ,From Formal Rules to Bison Input}.
 9207: @c
 9208: そのままに解釈される@footnote{【訳注】字句解析器によって}1文字です。
 9209: @xref{Grammar in Bison, ,From Formal Rules to Bison Input}。
 9210: 
 9211: @c @item Start symbol
 9212: @item Start symbol(開始記号)
 9213: @c The nonterminal symbol that stands for a complete valid utterance in
 9214: @c the language being parsed.  The start symbol is usually listed as the
 9215: @c first nonterminal symbol in a language specification.  
 9216: @c @xref{Start Decl, ,The Start-Symbol}.
 9217: @c
 9218: 構文解析された有効な言語の全体を表す非終端記号です。
 9219: 通常、言語仕様に書かれた最初の非終端記号です。
 9220: @xref{Start Decl, ,The Start-Symbol}。
 9221: 
 9222: @c @item Symbol table
 9223: @item Symbol table(記号表)
 9224: @c A data structure where symbol names and associated data are stored
 9225: @c during parsing to allow for recognition and use of existing
 9226: @c information in repeated uses of a symbol.
 9227: @c @xref{Multi-function Calc}.
 9228: @c
 9229: 繰り返し使われる記号の情報を認識して使うために、
 9230: 構文解析の途中で、記号の名前と関連する情報を記憶するデータ構造です。
 9231: @xref{Multi-function Calc}。
 9232: 
 9233: @c @item Token
 9234: @item Token(トークン)
 9235: @c A basic, grammatically indivisible unit of a language.  The symbol
 9236: @c that describes a token in the grammar is a terminal symbol.
 9237: @c The input of the Bison parser is a stream of tokens which comes from
 9238: @c the lexical analyzer.
 9239: @c @xref{Symbols}.
 9240: @c
 9241: 言語の、基本的で、文法的に分割できない単位です。
 9242: 文法の中のトークンを記述する記号を終端記号といいます。
 9243: Bison構文解析器の入力は、字句解析器からの、
 9244: トークンの流れです。
 9245: @xref{Symbols}。
 9246: 
 9247: @c @item Terminal symbol
 9248: @item Terminal symbol(終端記号)
 9249: @c A grammar symbol that has no rules in the grammar and therefore
 9250: @c is grammatically indivisible.  The piece of text it represents
 9251: @c is a token.
 9252: @c @xref{Language and Grammar, ,Languages and Context-Free Grammars}.
 9253: @c
 9254: 文法規則を持たず、したがって文法的に分割できない文法記号です。
 9255: これが表す文字の集まりをトークンといいます。
 9256: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 9257: @ignore
 9258: この行を含む3行は info ファイル作成時のエラーを回避するために挿入(編集担当)
 9259: @end ignore
 9260: @end table
 9261: 
 9262: 
 9263: @c =====================================================================
 9264: @node Index,  , Glossary, Top
 9265: @c @unnumbered Index
 9266: @unnumbered 索引
 9267: 
 9268: @printindex cp
 9269: 
 9270: @contents
 9271: 
 9272: @bye
 9273: 
 9274: 
 9275: 
 9276: 
 9277: @c old menu
 9278: 
 9279: * Introduction::
 9280: * Conditions::
 9281: * Copying::           The GNU General Public License says
 9282:                         how you can copy and share Bison
 9283: 
 9284: Tutorial sections:
 9285: * Concepts::          Basic concepts for understanding Bison.
 9286: * Examples::          Three simple explained examples of using Bison.
 9287: 
 9288: Reference sections:
 9289: * Grammar File::      Writing Bison declarations and rules.
 9290: * Interface::         C-language interface to the parser function @code{yyparse}.
 9291: * Algorithm::         How the Bison parser works at run-time.
 9292: * Error Recovery::    Writing rules for error recovery.
 9293: * Context Dependency::What to do if your language syntax is too
 9294:                         messy for Bison to handle straightforwardly.
 9295: * Debugging::         Debugging Bison parsers that parse wrong.
 9296: * Invocation::        How to run Bison (to produce the parser source file).
 9297: * Table of Symbols::  All the keywords of the Bison language are explained.
 9298: * Glossary::          Basic concepts are explained.
 9299: * Index::             Cross-references to the text.
 9300: 
 9301: 
 9302: 

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>