File:  [Local Repository] / gnujdoc / bison-1.28 / bison-ja.texinfo
Revision 1.4: download - view: text, annotated - select for diffs
Tue May 31 11:32:03 2005 UTC (15 years, 5 months ago) by futoshi
Branches: MAIN
CVS tags: HEAD
bison-1.28 delete one footnote :-(
flex-2.5.4 version down to flex-2.3.7 :-(
* @ifset does not work fine :-(

    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 Bison 1.25 から Bison 1.28 の変更点は
   10: @c 林芳樹 <t90553@mail.ecc.u-tokyo.ac.jp> が訳しました。
   11: @c
   12: @comment %**start of header
   13: @setfilename bison-ja.info
   14: @include bison-v.texi
   15: @settitle Bison @value{VERSION}
   16: @setchapternewpage odd
   17: 
   18: @iftex
   19: @finalout
   20: @end iftex
   21: 
   22: @c SMALL BOOK version   
   23: @c This edition has been formatted so that you can format and print it in
   24: @c the smallbook format. 
   25: @c @smallbook
   26: 
   27: @c Set following if you have the new `shorttitlepage' command
   28: @c @clear shorttitlepage-enabled
   29: @c @set shorttitlepage-enabled
   30: 
   31: @c infoファイル作成のため以下3行を追加(訳者)
   32: @c Following 3 lines are added by naota to make info file.
   33: @ifinfo
   34: @clear shorttitlepage-enabled
   35: @end ifinfo
   36: 
   37: @c ISPELL CHECK: done, 14 Jan 1993 --bob
   38: 
   39: @c Check COPYRIGHT dates.  should be updated in the titlepage, ifinfo
   40: @c titlepage; should NOT be changed in the GPL.  --mew
   41: 
   42: @iftex
   43: @syncodeindex fn cp
   44: @syncodeindex vr cp
   45: @syncodeindex tp cp
   46: @end iftex
   47: @ifinfo
   48: @synindex fn cp
   49: @synindex vr cp
   50: @synindex tp cp
   51: @end ifinfo
   52: @comment %**end of header
   53: 
   54: @ifinfo
   55: @format
   56: START-INFO-DIR-ENTRY
   57: * bison-ja: (bison-ja). GNU Project parser generator (yacc replacement).
   58: END-INFO-DIR-ENTRY
   59: @end format
   60: @end ifinfo
   61: 
   62: @ifinfo
   63: このファイルはBison構文解析器生成器の説明文書です。
   64: 
   65: Copyright (C) 1988, 89, 90, 91, 92, 93, 95, 98, 1999 Free Software Foundation, Inc.
   66: 
   67: Permission is granted to make and distribute verbatim copies of
   68: this manual provided the copyright notice and this permission notice
   69: are preserved on all copies.
   70: 
   71: @ignore
   72: Permission is granted to process this file through Tex and print the
   73: results, provided the printed document carries copying permission
   74: notice identical to this one except for the removal of this paragraph
   75: (this paragraph not being relevant to the printed manual).
   76: 
   77: @end ignore
   78: Permission is granted to copy and distribute modified versions of this
   79: manual under the conditions for verbatim copying, provided also that the
   80: sections entitled ``GNU General Public License'' and ``Conditions for
   81: Using Bison'' are included exactly as in the original, and provided that
   82: the entire resulting derived work is distributed under the terms of a
   83: permission notice identical to this one.
   84: 
   85: Permission is granted to copy and distribute translations of this manual
   86: into another language, under the above conditions for modified versions,
   87: except that the sections entitled ``GNU General Public License'',
   88: ``Conditions for Using Bison'' and this permission notice may be
   89: included in translations approved by the Free Software Foundation
   90: instead of in the original English.
   91: @end ifinfo
   92: 
   93: @ifset shorttitlepage-enabled
   94: @shorttitlepage Bison
   95: @end ifset
   96: @titlepage
   97: @title Bison入門
   98: @subtitle YACC互換構文解析器生成ツール
   99: @subtitle @value{UPDATED}, Bison Version @value{VERSION}
  100: 
  101: @author by Charles Donnelly and Richard Stallman
  102: @c 日本語訳:石川直太
  103: 
  104: @page
  105: @vskip 0pt plus 1filll
  106: Copyright @copyright{} 1988, 89, 90, 91, 92, 93, 95, 98, 1999 Free Software
  107: Foundation 
  108: 
  109: @sp 2
  110: Published by the Free Software Foundation @*
  111: 59 Temple Place, Suite 330 @*
  112: Boston, MA  02111-1307  USA @*
  113: Printed copies are available for $15 each.@*
  114: ISBN 1-882114-45-0
  115: 
  116: Permission is granted to make and distribute verbatim copies of
  117: this manual provided the copyright notice and this permission notice
  118: are preserved on all copies.
  119: 
  120: @ignore
  121: Permission is granted to process this file through TeX and print the
  122: results, provided the printed document carries copying permission
  123: notice identical to this one except for the removal of this paragraph
  124: (this paragraph not being relevant to the printed manual).
  125: 
  126: @end ignore
  127: Permission is granted to copy and distribute modified versions of this
  128: manual under the conditions for verbatim copying, provided also that the
  129: sections entitled ``GNU General Public License'' and ``Conditions for
  130: Using Bison'' are included exactly as in the original, and provided that
  131: the entire resulting derived work is distributed under the terms of a
  132: permission notice identical to this one.
  133: 
  134: Permission is granted to copy and distribute translations of this manual
  135: into another language, under the above conditions for modified versions,
  136: except that the sections entitled ``GNU General Public License'',
  137: ``Conditions for Using Bison'' and this permission notice may be
  138: included in translations approved by the Free Software Foundation
  139: instead of in the original English.
  140: @sp 2
  141: Cover art by Etienne Suvasa.
  142: @end titlepage
  143: @page
  144: 
  145: 
  146: @node Top, Introduction, (dir), (dir)
  147: 
  148: @ifinfo
  149: このマニュアルはBison @value{VERSION}の説明文書です。
  150: @end ifinfo
  151: 
  152: @menu
  153: * Introduction::      
  154: * Conditions::        
  155: * Copying::           GNU一般使用公有許諾書はBisonを複製したり共有したり
  156:                         する方法を示している
  157: 
  158: チュートリアル部分:
  159: * Concepts::          Bisonを理解するための基本概念.
  160: * Examples::          Bisonの利用を簡単に説明した3つの例.
  161: 
  162: 参照部分:
  163: * Grammar File::      Bisonの宣言と規則を書く.
  164: * Interface::         解析器関数@code{yyparse}へのC言語のインターフェース.
  165: * Algorithm::         Bison解析器が実行時に動作する方法.
  166: * Error Recovery::    エラー回復の規則を書く.
  167: * Context Dependency::  言語構文がBisonが率直に扱うには複雑すぎるときに
  168:                         何をすべきか.
  169: * Debugging::         間違った解析をするBison解析器のデバッグをする.
  170: * Invocation::        (解析器ソースファイルを生成するために)Bisonを実行
  171:                       する方法.
  172: * Table of Symbols::  Bisonの全てのキーワードの説明.
  173: * Glossary::          基本概念の説明.
  174: * Index::             テキストへの相互参照.
  175: 
  176:  --- The Detailed Node Listing ---
  177: 
  178: Bisonの概念
  179: 
  180: * Language and Grammar::  数学の発想と同じ、言語と文脈に依存しない文法.
  181: * Grammar in Bison::  Bisonのために文法を表現する方法.
  182: * Semantic Values::   それぞれのトークンや文法グループは意味値
  183:                         (整数の値、識別子の名前、など。)
  184:                          を取ることができる.
  185: * Semantic Actions::  それぞれの規則はCコードを含んだアクションを持つこ
  186:                         とができる.
  187: * Bison Parser::      Bisonの入力と出力な何で、出力はどのように使われる
  188:                        か。
  189: * Stages::            Bisonの文法を書いて実行させる手順.
  190: * Grammar Layout::    Bison文法ファイルの全体の構造.
  191: 
  192:   193: 
  194: * RPN Calc::          逆ポーランド記法電卓;
  195:                         演算子の優先順位が無い、最初の例.
  196: * Infix Calc::        中間(代数)記法電卓.
  197:                         演算子の優先順位が導入された.
  198: * Simple Error Recovery::  構文エラーの後も続行する.
  199: * Multi-function Calc::  メモリと三角関数付きの電卓.
  200:                            意味値に複数のデータ型を使用する.
  201: * Exercises::         多機能電卓を改善するための着想.
  202: 
  203: 逆ポーランド記法電卓
  204: 
  205: * Decls: Rpcalc Decls.  rpcalcのためのBisonとCの宣言.
  206: * Rules: Rpcalc Rules.  rpcalcのための文法規則。説明付き.
  207: * Lexer: Rpcalc Lexer.  字句解析器.
  208: * Main: Rpcalc Main.    制御関数.
  209: * Error: Rpcalc Error.  エラー報告関数.
  210: * Gen: Rpcalc Gen.      文法ファイルでBisonを実行する.
  211: * Comp: Rpcalc Compile. 出力コードにCコンパイラを実行する.
  212: 
  213: @code{rpcalc}のための文法規則
  214: 
  215: * Rpcalc Input::      
  216: * Rpcalc Line::       
  217: * Rpcalc Expr::       
  218: 
  219: 多機能電卓:@code{mfcalc}
  220: 
  221: * Decl: Mfcalc Decl.      多機能電卓のためのBisonの宣言.
  222: * Rules: Mfcalc Rules.    電卓のための文法規則.
  223: * Symtab: Mfcalc Symtab.  記号表を管理するサブルーチン.
  224: 
  225: Bison文法ファイル
  226: 
  227: * Grammar Outline::   文法ファイルの概略.
  228: * Symbols::           終端記号と非終端記号.
  229: * Rules::             文法規則の書き方.
  230: * Recursion::         再帰的規則の書き方.
  231: * Semantics::         意味値とアクション.
  232: * Declarations::      全ての種類のBison宣言の説明.
  233: * Multiple Parsers::  一つのプログラムに一つより多くのBison構文解析器を
  234:                         入れる.
  235: 
  236: Bison文法の概要
  237: 
  238: * C Declarations::    C宣言部の構文と使用法.
  239: * Bison Declarations::  Bison宣言部の構文と使用法.
  240: * Grammar Rules::     文法規則部の構文と使用法.
  241: * C Code::            追加のCコード部の構文と使用法.
  242: 
  243: 言語の意味の定義
  244: 
  245: * Value Type::        全ての意味値に一つのデータ型を指定する.
  246: * Multiple Types::    複数の別のデータ型を指定する.
  247: * Actions::           アクションは文法規則の意味的定義.
  248: * Action Types::      アクションが操作するデータ型を指定する.
  249: * Mid-Rule Actions::  ほとんどのアクションは規則の最後に行く.
  250:                       これは規則の最中で、いつ、なぜ、どのように
  251:                         例外アクションを使用するかを指示する.
  252: 
  253: Bison宣言
  254: 
  255: * Token Decl::        終端記号を宣言する.
  256: * Precedence Decl::   優先順位と結合規則とともに終端を宣言する.
  257: * Union Decl::        全ての意味値の型の集合を宣言する.
  258: * Type Decl::         非終端記号のための型の選択を宣言する.
  259: * Expect Decl::       シフト/還元衝突の警告を抑制する.
  260: * Start Decl::        開始記号を指定する.
  261: * Pure Decl::         再入構文解析器を要求する.
  262: * Decl Summary::      全てのBison宣言の表.
  263: 
  264: 構文解析器のC言語インターフェイス
  265: 
  266: * Parser Function::   @code{yyparse}の呼び方と、それが返すもの.
  267: * Lexical::           トークンを読み込む関数@code{yylex}を提供しなければ
  268:                         ならない.
  269: * Error Reporting::   関数@code{yyerror}を提供しなければならない.
  270: * Action Features::   アクションで使える特別な機能.
  271: 
  272: 字句解析器関数@code{yylex}
  273: 
  274: * Calling Convention::  @code{yyparse}が@code{yylex}を呼ぶ方法.
  275: * Token Values::      @code{yylex}がどのように読み込んだトークンの
  276:                         意味値を返さなければならないか.
  277: * Token Positions::   アクションが望むときに、どのように@code{yylex}が
  278:                         テキストの位置(行数など)を返さなければならない
  279:                         か。
  280: * Pure Calling::      純粋な構文解析器で呼び出し型の習慣がどのように
  281:                         違うか (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).
  282: 
  283: Bison構文解析器のアルゴリズム
  284: 
  285: * Look-Ahead::        構文解析器は何をするかを決めるときに一つ先のトーク
  286:                         ンを見る.
  287: * Shift/Reduce::      衝突: シフトと還元の両方が有効なとき.
  288: * Precedence::        演算子の優先順位は衝突を解決することで動作する.
  289: * Contextual Precedence::  演算子の優先順位が文脈に依存するとき.
  290: * Parser States::     構文解析器はスタック付きの有限状態機械.
  291: * Reduce/Reduce::     同じ状況に2つの規則が適用可能なとき.
  292: * Mystery Conflicts::  正しくないように見える還元/還元衝突.
  293: * Stack Overflow::    スタックが一杯になったときに何が起こるうか. それを
  294:                         避ける方法.
  295: 
  296: 演算子の優先順位
  297: 
  298: * Why Precedence::    優先順位が必要なことを示す例.
  299: * Using Precedence::  Bison文法で優先順位を指定する方法.
  300: * Precedence Examples::  前の例でこれらの機能が使われた方法.
  301: * How Precedence::    どのように動作するか.
  302: 
  303: 文脈依存性の処理
  304: 
  305: * Semantic Tokens::   トークン構文解析は意味的文脈に依存する.
  306: * Lexical Tie-ins::   トークン構文解析は構文的文脈に依存する.
  307: * Tie-in Recovery::   字句結び付きはエラー回復規則を書く方法に影響する.
  308: 
  309: Bisonの実行
  310: 
  311: * Bison Options::     全てのオプションが詳しく、短いオプションでアルファ
  312:                         ベット順に説明されている.
  313: * Option Cross Key::  長いオプションのアルファッベット順のリスト.
  314: * VMS Invocation::    VMSでのBisonのコマンド構文.
  315: @end menu
  316: 
  317: @node Introduction, Conditions, Top, Top
  318: @unnumbered まえがき
  319: @cindex introduction
  320: @cindex まえがき
  321: 
  322: Bisonは、LALR(1)文脈自由文法の文法定義を、
  323: その文法を解析するためのCで書かれたプログラムに変換する、
  324: 汎用の構文解析器生成ツールです。
  325: あなたがBisonに熟練すれば、
  326: 簡単な電卓から複雑なプログラミング言語まで、
  327: 広い範囲の言語解析器を開発できるようになるでしょう。
  328: 
  329: BisonはYaccの上位互換です。
  330: 正しく書かれたすべてのYacc文法を、変更なくBisonで処理できます。
  331: Yaccに親しんでいるすべての人は、ちょっと考えるだけで、
  332: Bisonを使えるようになるでしょう。
  333: Bisonを使い、本書を理解するためには、
  334: C言語に精通している必要があります。
  335: 
  336: 1章と2章は入門の章です。1章では、Bisonを使うための基本的な概念を説明し、
  337: 2章では3つの具体例を示します。
  338: BisonやYaccを知らない方は、
  339: 1章から読みはじめてください。
  340: 3章以降では、Bisonの仕様を詳細に解説します。
  341: 
  342: Bisonは、最初にRobert Corbettによって開発され、
  343: Richard StallmanがYacc互換にしました。
  344: カーネギーメロン大学のWilfred Hansenが、
  345: 文字列リテラル@footnote{【訳注】2文字以上の文字列、たとえば@samp{==}を、
  346: トークン名に使う機能。}といくつかの機能を追加しました。
  347: 
  348: 本書は、Bisonのバージョン@value{VERSION}に基づいています。
  349: 
  350: @unnumberedsec 日本語訳にあたって
  351: 
  352: 本書は、株式会社アスキーの
  353: 支援を受けて、慶應義塾の石川直太
  354: (@samp{naota@@sfc.keio.ac.jp、http://www.sfc.keio.ac.jp/~naota/})
  355: が翻訳しました。
  356: 
  357: なお、「GNU一般公有使用許諾書」の日本語訳については、
  358: 引地さんのところの日本語訳を使わせていただいたことを
  359: ここに記して感謝いたします。
  360: 
  361: 日本語訳したtexinfoファイルは、
  362: @samp{http://www.ascii.co.jp/pub/GNU/bison-1.25-man-jp.tgz}
  363: にあります。コマンドtexi2dviなどでdviファイルを生成したり、GNU Emacsで
  364: infoファイルへ変換したりできます。
  365: 
  366: バージョン1.25 からバージョン@value{VERSION}の変更はgnujdocプロジェクトの
  367: 一環として林芳樹 (@email{t90553@@mail.ecc.u-tokyo.ac.jp}) が
  368: 行いました。
  369: 
  370: gnujdoc の詳細は、
  371: @uref{http://duff.kuicr.kyoto-u.ac.jp/%7Eokuji/gnujdoc/}
  372: を参照してください。
  373: 
  374: @node Conditions, Copying, Introduction, Top
  375: @unnumbered Bisonの利用条件
  376: 
  377: Bisonバージョン1.24において、フリーでないプログラムへのBisonの出力の
  378: 利用を許可するために、@code{yyparse}の配布条件を変えました。
  379: それまでは、Bisonによって生成された構文解析器は、
  380: フリーソフトウェアのプログラム中でのみ、利用可能でした。
  381: 
  382: GNU Cコンパイラなど他のGNUプログランミングツールには、
  383: このような制限がありません。
  384: それらは、いつでも、フリーでないソフトウェアの開発に利用できます。
  385: Bisonの利用条件が異なっていた理由は、特別な政治的判断によるものではありません。
  386: BisonのすべてのソースコードにGPLを適用した結果です。
  387: 
  388: Bisonの出力であるBison構文解析器ファイルには、
  389: @code{yyparse}関数のためのコードである、
  390: かなりの量のBisonのソースコードの一部分が、そのまま含まれます
  391: (あなたが定義した文法によるアクションは、
  392: この関数の1か所に挿入されるだけで、残りの関数は変わりません)。
  393: われわれFSFが@code{yyparse}のコードにGPLを適用した結果、
  394: Bisonの出力をフリーソフトウェアのみに利用するという制約ができたのです。
  395: 
  396: ソフトウェアを専売しようとする人々への思いやりによって、
  397: われわれが条件を変えることはありませんでした。
  398: @strong{ソフトウェアはフリーであるべきです。}
  399: しかし、われわれは、Bisonの利用をフリーソフトウェアに限定したことは、
  400: 他のソフトウェアをフリーにしようとする人々を勇気づけるために、
  401: 少なからず役立っただろうと、結論を下しました。
  402: そこで、われわれは、その他のGNUツールの現実的な利用条件に合わせて、
  403: Bisonの現実的な利用条件を決定することにしました。
  404: 
  405: 
  406: @node Copying, Concepts, Conditions, Top
  407: @unnumbered GNU GENERAL PUBLIC LICENSE
  408: @center Version 2, June 1991
  409: 
  410: @display
  411: Copyright @copyright{} 1989, 1991 Free Software Foundation, Inc.
  412: 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  413: 
  414: Everyone is permitted to copy and distribute verbatim copies
  415: of this license document, but changing it is not allowed.
  416: @end display
  417: 
  418: @unnumberedsec Preamble
  419: 
  420:   The licenses for most software are designed to take away your
  421: freedom to share and change it.  By contrast, the GNU General Public
  422: License is intended to guarantee your freedom to share and change free
  423: software---to make sure the software is free for all its users.  This
  424: General Public License applies to most of the Free Software
  425: Foundation's software and to any other program whose authors commit to
  426: using it.  (Some other Free Software Foundation software is covered by
  427: the GNU Library General Public License instead.)  You can apply it to
  428: your programs, too.
  429: 
  430:   When we speak of free software, we are referring to freedom, not
  431: price.  Our General Public Licenses are designed to make sure that you
  432: have the freedom to distribute copies of free software (and charge for
  433: this service if you wish), that you receive source code or can get it
  434: if you want it, that you can change the software or use pieces of it
  435: in new free programs; and that you know you can do these things.
  436: 
  437:   To protect your rights, we need to make restrictions that forbid
  438: anyone to deny you these rights or to ask you to surrender the rights.
  439: These restrictions translate to certain responsibilities for you if you
  440: distribute copies of the software, or if you modify it.
  441: 
  442:   For example, if you distribute copies of such a program, whether
  443: gratis or for a fee, you must give the recipients all the rights that
  444: you have.  You must make sure that they, too, receive or can get the
  445: source code.  And you must show them these terms so they know their
  446: rights.
  447: 
  448:   We protect your rights with two steps: (1) copyright the software, and
  449: (2) offer you this license which gives you legal permission to copy,
  450: distribute and/or modify the software.
  451: 
  452:   Also, for each author's protection and ours, we want to make certain
  453: that everyone understands that there is no warranty for this free
  454: software.  If the software is modified by someone else and passed on, we
  455: want its recipients to know that what they have is not the original, so
  456: that any problems introduced by others will not reflect on the original
  457: authors' reputations.
  458: 
  459:   Finally, any free program is threatened constantly by software
  460: patents.  We wish to avoid the danger that redistributors of a free
  461: program will individually obtain patent licenses, in effect making the
  462: program proprietary.  To prevent this, we have made it clear that any
  463: patent must be licensed for everyone's free use or not licensed at all.
  464: 
  465:   The precise terms and conditions for copying, distribution and
  466: modification follow.
  467: 
  468: @iftex
  469: @unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  470: @end iftex
  471: @ifinfo
  472: @center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  473: @end ifinfo
  474: 
  475: @enumerate 0
  476: @item
  477: This License applies to any program or other work which contains
  478: a notice placed by the copyright holder saying it may be distributed
  479: under the terms of this General Public License.  The ``Program'', below,
  480: refers to any such program or work, and a ``work based on the Program''
  481: means either the Program or any derivative work under copyright law:
  482: that is to say, a work containing the Program or a portion of it,
  483: either verbatim or with modifications and/or translated into another
  484: language.  (Hereinafter, translation is included without limitation in
  485: the term ``modification''.)  Each licensee is addressed as ``you''.
  486: 
  487: Activities other than copying, distribution and modification are not
  488: covered by this License; they are outside its scope.  The act of
  489: running the Program is not restricted, and the output from the Program
  490: is covered only if its contents constitute a work based on the
  491: Program (independent of having been made by running the Program).
  492: Whether that is true depends on what the Program does.
  493: 
  494: @item
  495: You may copy and distribute verbatim copies of the Program's
  496: source code as you receive it, in any medium, provided that you
  497: conspicuously and appropriately publish on each copy an appropriate
  498: copyright notice and disclaimer of warranty; keep intact all the
  499: notices that refer to this License and to the absence of any warranty;
  500: and give any other recipients of the Program a copy of this License
  501: along with the Program.
  502: 
  503: You may charge a fee for the physical act of transferring a copy, and
  504: you may at your option offer warranty protection in exchange for a fee.
  505: 
  506: @item
  507: You may modify your copy or copies of the Program or any portion
  508: of it, thus forming a work based on the Program, and copy and
  509: distribute such modifications or work under the terms of Section 1
  510: above, provided that you also meet all of these conditions:
  511: 
  512: @enumerate a
  513: @item
  514: You must cause the modified files to carry prominent notices
  515: stating that you changed the files and the date of any change.
  516: 
  517: @item
  518: You must cause any work that you distribute or publish, that in
  519: whole or in part contains or is derived from the Program or any
  520: part thereof, to be licensed as a whole at no charge to all third
  521: parties under the terms of this License.
  522: 
  523: @item
  524: If the modified program normally reads commands interactively
  525: when run, you must cause it, when started running for such
  526: interactive use in the most ordinary way, to print or display an
  527: announcement including an appropriate copyright notice and a
  528: notice that there is no warranty (or else, saying that you provide
  529: a warranty) and that users may redistribute the program under
  530: these conditions, and telling the user how to view a copy of this
  531: License.  (Exception: if the Program itself is interactive but
  532: does not normally print such an announcement, your work based on
  533: the Program is not required to print an announcement.)
  534: @end enumerate
  535: 
  536: These requirements apply to the modified work as a whole.  If
  537: identifiable sections of that work are not derived from the Program,
  538: and can be reasonably considered independent and separate works in
  539: themselves, then this License, and its terms, do not apply to those
  540: sections when you distribute them as separate works.  But when you
  541: distribute the same sections as part of a whole which is a work based
  542: on the Program, the distribution of the whole must be on the terms of
  543: this License, whose permissions for other licensees extend to the
  544: entire whole, and thus to each and every part regardless of who wrote it.
  545: 
  546: Thus, it is not the intent of this section to claim rights or contest
  547: your rights to work written entirely by you; rather, the intent is to
  548: exercise the right to control the distribution of derivative or
  549: collective works based on the Program.
  550: 
  551: In addition, mere aggregation of another work not based on the Program
  552: with the Program (or with a work based on the Program) on a volume of
  553: a storage or distribution medium does not bring the other work under
  554: the scope of this License.
  555: 
  556: @item
  557: You may copy and distribute the Program (or a work based on it,
  558: under Section 2) in object code or executable form under the terms of
  559: Sections 1 and 2 above provided that you also do one of the following:
  560: 
  561: @enumerate a
  562: @item
  563: Accompany it with the complete corresponding machine-readable
  564: source code, which must be distributed under the terms of Sections
  565: 1 and 2 above on a medium customarily used for software interchange; or,
  566: 
  567: @item
  568: Accompany it with a written offer, valid for at least three
  569: years, to give any third party, for a charge no more than your
  570: cost of physically performing source distribution, a complete
  571: machine-readable copy of the corresponding source code, to be
  572: distributed under the terms of Sections 1 and 2 above on a medium
  573: customarily used for software interchange; or,
  574: 
  575: @item
  576: Accompany it with the information you received as to the offer
  577: to distribute corresponding source code.  (This alternative is
  578: allowed only for noncommercial distribution and only if you
  579: received the program in object code or executable form with such
  580: an offer, in accord with Subsection b above.)
  581: @end enumerate
  582: 
  583: The source code for a work means the preferred form of the work for
  584: making modifications to it.  For an executable work, complete source
  585: code means all the source code for all modules it contains, plus any
  586: associated interface definition files, plus the scripts used to
  587: control compilation and installation of the executable.  However, as a
  588: special exception, the source code distributed need not include
  589: anything that is normally distributed (in either source or binary
  590: form) with the major components (compiler, kernel, and so on) of the
  591: operating system on which the executable runs, unless that component
  592: itself accompanies the executable.
  593: 
  594: If distribution of executable or object code is made by offering
  595: access to copy from a designated place, then offering equivalent
  596: access to copy the source code from the same place counts as
  597: distribution of the source code, even though third parties are not
  598: compelled to copy the source along with the object code.
  599: 
  600: @item
  601: You may not copy, modify, sublicense, or distribute the Program
  602: except as expressly provided under this License.  Any attempt
  603: otherwise to copy, modify, sublicense or distribute the Program is
  604: void, and will automatically terminate your rights under this License.
  605: However, parties who have received copies, or rights, from you under
  606: this License will not have their licenses terminated so long as such
  607: parties remain in full compliance.
  608: 
  609: @item
  610: You are not required to accept this License, since you have not
  611: signed it.  However, nothing else grants you permission to modify or
  612: distribute the Program or its derivative works.  These actions are
  613: prohibited by law if you do not accept this License.  Therefore, by
  614: modifying or distributing the Program (or any work based on the
  615: Program), you indicate your acceptance of this License to do so, and
  616: all its terms and conditions for copying, distributing or modifying
  617: the Program or works based on it.
  618: 
  619: @item
  620: Each time you redistribute the Program (or any work based on the
  621: Program), the recipient automatically receives a license from the
  622: original licensor to copy, distribute or modify the Program subject to
  623: these terms and conditions.  You may not impose any further
  624: restrictions on the recipients' exercise of the rights granted herein.
  625: You are not responsible for enforcing compliance by third parties to
  626: this License.
  627: 
  628: @item
  629: If, as a consequence of a court judgment or allegation of patent
  630: infringement or for any other reason (not limited to patent issues),
  631: conditions are imposed on you (whether by court order, agreement or
  632: otherwise) that contradict the conditions of this License, they do not
  633: excuse you from the conditions of this License.  If you cannot
  634: distribute so as to satisfy simultaneously your obligations under this
  635: License and any other pertinent obligations, then as a consequence you
  636: may not distribute the Program at all.  For example, if a patent
  637: license would not permit royalty-free redistribution of the Program by
  638: all those who receive copies directly or indirectly through you, then
  639: the only way you could satisfy both it and this License would be to
  640: refrain entirely from distribution of the Program.
  641: 
  642: If any portion of this section is held invalid or unenforceable under
  643: any particular circumstance, the balance of the section is intended to
  644: apply and the section as a whole is intended to apply in other
  645: circumstances.
  646: 
  647: It is not the purpose of this section to induce you to infringe any
  648: patents or other property right claims or to contest validity of any
  649: such claims; this section has the sole purpose of protecting the
  650: integrity of the free software distribution system, which is
  651: implemented by public license practices.  Many people have made
  652: generous contributions to the wide range of software distributed
  653: through that system in reliance on consistent application of that
  654: system; it is up to the author/donor to decide if he or she is willing
  655: to distribute software through any other system and a licensee cannot
  656: impose that choice.
  657: 
  658: This section is intended to make thoroughly clear what is believed to
  659: be a consequence of the rest of this License.
  660: 
  661: @item
  662: If the distribution and/or use of the Program is restricted in
  663: certain countries either by patents or by copyrighted interfaces, the
  664: original copyright holder who places the Program under this License
  665: may add an explicit geographical distribution limitation excluding
  666: those countries, so that distribution is permitted only in or among
  667: countries not thus excluded.  In such case, this License incorporates
  668: the limitation as if written in the body of this License.
  669: 
  670: @item
  671: The Free Software Foundation may publish revised and/or new versions
  672: of the General Public License from time to time.  Such new versions will
  673: be similar in spirit to the present version, but may differ in detail to
  674: address new problems or concerns.
  675: 
  676: Each version is given a distinguishing version number.  If the Program
  677: specifies a version number of this License which applies to it and ``any
  678: later version'', you have the option of following the terms and conditions
  679: either of that version or of any later version published by the Free
  680: Software Foundation.  If the Program does not specify a version number of
  681: this License, you may choose any version ever published by the Free Software
  682: Foundation.
  683: 
  684: @item
  685: If you wish to incorporate parts of the Program into other free
  686: programs whose distribution conditions are different, write to the author
  687: to ask for permission.  For software which is copyrighted by the Free
  688: Software Foundation, write to the Free Software Foundation; we sometimes
  689: make exceptions for this.  Our decision will be guided by the two goals
  690: of preserving the free status of all derivatives of our free software and
  691: of promoting the sharing and reuse of software generally.
  692: 
  693: @iftex
  694: @heading NO WARRANTY
  695: @end iftex
  696: @ifinfo
  697: @center NO WARRANTY
  698: @end ifinfo
  699: 
  700: @item
  701: BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
  702: FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW@.  EXCEPT WHEN
  703: OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
  704: PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
  705: OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  706: MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE@.  THE ENTIRE RISK AS
  707: TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU@.  SHOULD THE
  708: PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
  709: REPAIR OR CORRECTION.
  710: 
  711: @item
  712: IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  713: WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
  714: REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
  715: INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
  716: OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
  717: TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
  718: YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
  719: PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
  720: POSSIBILITY OF SUCH DAMAGES.
  721: @end enumerate
  722: 
  723: @iftex
  724: @heading END OF TERMS AND CONDITIONS
  725: @end iftex
  726: @ifinfo
  727: @center END OF TERMS AND CONDITIONS
  728: @end ifinfo
  729: 
  730: @page
  731: @unnumberedsec How to Apply These Terms to Your New Programs
  732: 
  733:   If you develop a new program, and you want it to be of the greatest
  734: possible use to the public, the best way to achieve this is to make it
  735: free software which everyone can redistribute and change under these terms.
  736: 
  737:   To do so, attach the following notices to the program.  It is safest
  738: to attach them to the start of each source file to most effectively
  739: convey the exclusion of warranty; and each file should have at least
  740: the ``copyright'' line and a pointer to where the full notice is found.
  741: 
  742: @smallexample
  743: @var{one line to give the program's name and an idea of what it does.}
  744: Copyright (C) 19@var{yy}  @var{name of author}
  745: 
  746: This program is free software; you can redistribute it and/or
  747: modify it under the terms of the GNU General Public License
  748: as published by the Free Software Foundation; either version 2
  749: of the License, or (at your option) any later version.
  750: 
  751: This program is distributed in the hope that it will be useful,
  752: but WITHOUT ANY WARRANTY; without even the implied warranty of
  753: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE@.  See the
  754: GNU General Public License for more details.
  755: 
  756: You should have received a copy of the GNU General Public License along
  757: with this program; if not, write to the Free Software Foundation, Inc.,
  758: 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
  759: @end smallexample
  760: 
  761: Also add information on how to contact you by electronic and paper mail.
  762: 
  763: If the program is interactive, make it output a short notice like this
  764: when it starts in an interactive mode:
  765: 
  766: @smallexample
  767: Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
  768: Gnomovision comes with ABSOLUTELY NO WARRANTY; for details
  769: type `show w'.  This is free software, and you are welcome
  770: to redistribute it under certain conditions; type `show c' 
  771: for details.
  772: @end smallexample
  773: 
  774: The hypothetical commands @samp{show w} and @samp{show c} should show
  775: the appropriate parts of the General Public License.  Of course, the
  776: commands you use may be called something other than @samp{show w} and
  777: @samp{show c}; they could even be mouse-clicks or menu items---whatever
  778: suits your program.
  779: 
  780: You should also get your employer (if you work as a programmer) or your
  781: school, if any, to sign a ``copyright disclaimer'' for the program, if
  782: necessary.  Here is a sample; alter the names:
  783: 
  784: @smallexample
  785: @group
  786: Yoyodyne, Inc., hereby disclaims all copyright
  787: interest in the program `Gnomovision'
  788: (which makes passes at compilers) written 
  789: by James Hacker.
  790: 
  791: @var{signature of Ty Coon}, 1 April 1989
  792: Ty Coon, President of Vice
  793: @end group
  794: @end smallexample
  795: 
  796: This General Public License does not permit incorporating your program into
  797: proprietary programs.  If your program is a subroutine library, you may
  798: consider it more useful to permit linking proprietary applications with the
  799: library.  If this is what you want to do, use the GNU Library General
  800: Public License instead of this License.
  801: 
  802: 
  803: @node Concepts, Examples, Copying, Top
  804: @chapter Bisonの概念
  805: 
  806: この章では、Bisonの詳細を理解するのに欠くことのできない、
  807: 多くの基礎概念を説明します。
  808: まだBisonやyaccの使い方を知らない方は、
  809: この章を注意深く読むことから始めてください。
  810: 
  811: @menu
  812: * Language and Grammar::  数学の発想と同じ、言語と文脈に依存しない文法.
  813: * Grammar in Bison::  Bisonのために文法を表現する方法.
  814: * Semantic Values::   それぞれのトークンや文法グループは意味値
  815:                         (整数の値、識別子の名前、など。)
  816:                          を取ることができる.
  817: * Semantic Actions::  それぞれの規則はCコードを含んだアクションを持つこ
  818:                         とができる.
  819: * Bison Parser::      Bisonの入力と出力な何で、出力はどのように使われる
  820:                        か。
  821: * Stages::            Bisonの文法を書いて実行させる手順.
  822: * Grammar Layout::    Bison文法ファイルの全体の構造.
  823: @end menu
  824: 
  825: 
  826: @node Language and Grammar, Grammar in Bison,  , Concepts
  827: @section 言語と文脈自由文法
  828: 
  829: @cindex context-free grammar
  830: @cindex grammar, context-free
  831: @cindex 文脈自由文法
  832: @cindex 文法
  833: 
  834: Bisonが言語を解析するためには、その言語が
  835: @dfn{文脈自由文法(context-free grammar)}で記述されている必要があります。
  836: すなわち、1個以上の@dfn{文法グループ(syntactic groupings)}を定め、
  837: その文法グループを部品から組み立てる規則を与える必要があります。
  838: たとえば、C言語では、ある種のグループは「式」と呼ばれます。
  839: 式を作る規則の1つは、
  840: 「1つの式とは、別の式にマイナス記号を付けたものでもよい」かもしれません。
  841: 別の規則は、「1つの式とは、整数でもよい」かもしれません。
  842: ここから解るように、規則はしばしば再帰的になりますが、
  843: 再帰を始めるための少なくとも1個の規則が必要です。
  844: 
  845: @cindex BNF
  846: @cindex Backus-Naur form
  847: @cindex バッカス-ナウア記法
  848: 
  849: このような規則を人間が読めるように表現する、もっとも一般的な形式的な方法は、
  850: @dfn{バッカス-ナウア記法(Backus-Naur form)}略して``BNF''です。
  851: これは、Algol 60言語を定義するために開発されました。
  852: BNFで表現された任意の言語は、文脈自由言語です。
  853: Bisonへの入力は、本質的には、機械可読なBNFです。
  854: 
  855: すべての文脈自由言語をBisonで扱えるわけではありません。
  856: LALR(1)だけを扱えます。
  857: 簡単に説明すると、ちょうど1個のトークンを先読みすることによって、
  858: 入力文字列の任意の部分を解析できる必要があるということです。
  859: 厳密に説明すると、これはLR(1)文法の説明で、
  860: LALR(1)には簡単に説明できない追加の制限があります。
  861: しかし、LALR(1)になれないLR(1)文法は、現実にはまれです。
  862: より詳しい説明は
  863: @xref{Mystery Conflicts, , Mysterious Reduce/Reduce Conflicts}。
  864: 
  865: @cindex symbols (abstract)
  866: @cindex token
  867: @cindex syntactic grouping
  868: @cindex grouping, syntactic
  869: @cindex シンボル
  870: @cindex 記号
  871: @cindex 終端記号
  872: @cindex 非終端記号
  873: @cindex トークン
  874: @cindex 文法グループ
  875: @cindex グループ
  876: 
  877: ある言語についての形式文法的な規則では、
  878: 文法的な単位またはグループを@dfn{記号(symbol)}と呼びます。
  879: 文法規則に従って小さい部分から組み立てられた記号を
  880: @dfn{非終端記号(nonterminal symbol)}といい、
  881: @dfn{終端記号(terminal symbol)}または@dfn{トークン型(token type)}と呼ばれる
  882: ものに分解できます。
  883: 本書では、1個の終端記号に対応する入力の一部分を@dfn{トークン(token)}、
  884: 1個の非終端記号に対応する入力の一部分を@dfn{グループ(grouping)}と呼びます。
  885: 
  886: 何が終端記号で何が非終端記号かを示すために、
  887: 例としてC言語を使います。
  888: Cのトークンは、識別子、定数(数値または文字列)、さまざまな予約語、
  889: 算術演算子、区切り記号です。
  890: C言語の終端記号には、「識別子」、「数値」、「文字列」、そして、
  891: 予約語、演算子、区切り記号のそれぞれに対する記号、
  892: すなわち、「if」、「return」、「const」、「static」、「int」、「char」、
  893: 「プラス記号」、「開きブレース」、「閉じブレース」、「カンマ」、
  894: などが含まれます
  895: (これらのトークンは文字に分解できますが、
  896: それは文法の問題ではなく、字句解析の問題です)。
  897: 
  898: 次の例は、トークンに分解されたCの関数です。
  899: 
  900: @example
  901: int             /* @r{予約語 `int'} */
  902: square (x)      /* @r{識別子, 開きかっこ,} */
  903:                 /* @r{識別子, 閉じかっこ} */
  904:      int x;     /* @r{予約語 `int', 識別子, セミコロン} */
  905: @{               /* @r{開きブレース} */
  906:   return x * x; /* @r{予約語 `return', 識別子,} */
  907:                 /* @r{アスタリスク, 識別子, セミコロン} */
  908: @}               /* @r{閉じブレース} */
  909: @end example
  910: 
  911: Cの文法的なグループには、式、文、宣言、関数定義が含まれます。
  912: これらは、Cの文法で、非終端記号、「式」、「文」、「宣言」、
  913: 「関数定義」として表されます。
  914: 完全な文法では、上記の4つの意味を表現するために、
  915: それぞれの非終端記号について、数十個の追加の言語構築が必要です。
  916: 上記の例で、関数定義は、宣言と文を含みます。
  917: 文の中で、それぞれの@samp{x}は式であり、
  918: @samp{x * x}も式です。
  919: 
  920: それぞれの非終端記号には、それがより単純な構成要素からどのように作られるか
  921: 示すために、文法規則が必要です。
  922: たとえば、Cの文の1つである@code{return}文について、
  923: 文法規則を形式ばらずに書くと、次のようになります。
  924: 
  925: @quotation
  926: 「文」は、キーワード「@code{return}」、「式」、「セミコロン」から
  927: 作ることができる。
  928: @end quotation
  929: 
  930: @noindent
  931: Cの各種の文について、「文」には多くの他の規則があるでしょう。
  932: 
  933: @cindex start symbol
  934: @cindex 開始記号
  935: 1つの非終端記号が、言語の全体を表現するように、
  936: 特別なものとして識別される必要があります。
  937: これを@dfn{開始記号(start symbol)}と呼びます。
  938: コンパイラでは、これは完全な入力プログラムを意味します。
  939: C言語では、非終端記号「定義と宣言の並び」が、この働きをします。
  940: 
  941: たとえば、@samp{1 + 2}は有効なCの式で、
  942: Cのプログラムの有効な一部分ですが、
  943: Cプログラム@emph{全体}としては無効です。
  944: したがって、Cの文脈自由文法では、「式」は開始記号でないとわかります。
  945: 
  946: Bison構文解析器は、入力としてトークンの列を読み、
  947: 文法規則を使ってトークンをグループにします。
  948: もし入力が有効であれば、最終的な結果として、トークンの列全体が
  949: 文法の開始記号である1つのグループの記号に還元されます。
  950: もしわれわれがCの文法を使うならば、入力全体は
  951: 「定義と宣言の列」の必要があります。
  952: もしそうでなければ、構文解析器が文法エラーを報告します。
  953: 
  954: 
  955: @node Grammar in Bison, Semantic Values, Language and Grammar, Concepts
  956: @section 形式規則からBisonの入力へ
  957: @cindex Bison grammar
  958: @cindex Bison 文法
  959: @cindex grammar, Bison
  960: @cindex formal grammar
  961: @cindex 形式文法
  962: 
  963: 形式文法(formal grammer)は、数学的な構成です。
  964: Bisonのために言語を定義するためには、Bisonの書式で文法を記述した
  965: @dfn{Bison文法(Bison grammer)}ファイルを書く必要があります。
  966: @xref{Grammar File, ,Bison Grammar Files}。
  967: 
  968: 形式文法の中での1つの非終端記号は、Bisonの入力の中で、
  969: Cの識別子のような、1つの識別子として表現されます。
  970: @code{expr}、@code{stmt}、@code{declaration}のように、
  971: 通常、非終端記号は小文字で書きます。
  972: 
  973: 終端記号に対するBisonの表現は、
  974: @dfn{トークン型(token type)}ともいいます。
  975: トークン型は、C言語で使われるような識別子であるかもしれません。
  976: 通常、非終端記号からこれらを区別するために、大文字で書きます。
  977: たとえば、@code{INTEGER}、@code{IDENTIFIER}、@code{IF}、@code{RETURN}
  978: のように書きます。
  979: 言語の個々のキーワードを表す終端記号は、
  980: キーワードを大文字に変換してから命名するべきです。
  981: @cindex error
  982: 終端記号@code{error}は、エラーからの回復処理のために予約されています。
  983: @xref{Symbols}。
  984: 
  985: ある終端記号は、C言語の文字定数のような、1文字リテラルを表している
  986: かもしれません。
  987: トークンがちょうど1文字である(たとえば、かっこ、プラス記号など)ならば必ず、
  988: そのトークンに対する終端記号として、同じ文字を使うべきです。
  989: 
  990: 終端記号を表す第3の方法は、何文字かを含むC言語の文字列定数です。
  991: 詳細は@xref{Symbols}。
  992: 
  993: 文法規則は、Bisonの文法の中で、もう1つの式を持ちます。
  994: たとえば、C言語の@code{return}文に対するBisonの規則があります。
  995: クォート(')で囲まれたセミコロンは、文に対するC言語の文法の一部分を表す、
  996: 1文字のリテラルトークンです。
  997: クォートで囲まれていないセミコロンとコロンは、
  998: あらゆる規則の中で使われる、Bisonの区切り文字です。
  999: 
 1000: @example
 1001: stmt:   RETURN expr ';'
 1002:         ;
 1003: @end example
 1004: 
 1005: @noindent
 1006: @xref{Rules, ,Syntax of Grammar Rules}。
 1007: 
 1008: 
 1009: @node Semantic Values, Semantic Actions, Grammar in Bison, Concepts
 1010: @section 意味値
 1011: @cindex semantic value
 1012: @cindex value, semantic
 1013: @cindex 意味値
 1014: @cindex 値
 1015: 
 1016: 形式文法は、トークンを分類法に基づいてのみ、選びます。
 1017: たとえば、ある規則が`integer constant'という終端記号について言及するならば、
 1018: それは、文法的にそこに現れてよい@emph{任意の}整数型定数を意味します。
 1019: その定数の正確な値は、入力が解析される方法と無関係です。
 1020: もし、@samp{x+4}が文法的に正しいならば、@samp{x+1}も、@samp{x+3989}も、
 1021: 同様に文法的に正しいのです。
 1022: 
 1023: しかし、いったん解析されれば、入力にとって正確な値はきわめて重要です。
 1024: プログラム中の定数として4と1と3989を区別できないコンパイラは、
 1025: 役に立ちません。
 1026: そこで、Bison文法の中のそれぞれのトークンは、トークン型のほかに、
 1027: @dfn{意味値(semantic value)}を持ちます。詳細については、
 1028: @xref{Semantics, ,Defining Language Semantics}。
 1029: 
 1030: トークン型は、@code{INTEGER}、@code{IDENTIFIER}、@code{','}のように、
 1031: 文法の中で定義される終端記号です。
 1032: これは、そのトークンが正しい位置に現れているか確かめ、
 1033: 他のトークンとどのようにグループ化するか決めるために必要な、
 1034: すべての情報を含んでいます。
 1035: 文法規則は、トークンの型以外の何も知りません。
 1036: 
 1037: 意味値は、トークンに関する、たとえば、整数の値や識別子の名前のような、
 1038: トークン型以外のあらゆる情報を持っています
 1039: (@code{','}のような区切り記号であるトークンは、
 1040: 意味値を持つ必要がありません)。
 1041: 
 1042: たとえば、ある入力されたトークンは、トークン型が@code{INTEGER}で、
 1043: 意味値が4であると分類されるかもしれません。
 1044: 別の入力されたトークンは、同じ@code{INTEGER}型で、
 1045: 値が3989であるかもしれません。
 1046: 文法規則が@code{INTEGER}の出現を許すのならば、
 1047: どちらのトークンも@code{INTEGER}型なので、受け入れられます。
 1048: 構文解析器は、トークンを受け入れるときに、その意味値を記憶します。
 1049: 
 1050: それぞれのグループ化は、それに対応する非終端記号とともに、意味値を持てます。
 1051: たとえば、電卓の中では、1つの式は、通常、数値である意味値を持ちます。
 1052: プログラミング言語のコンパイラの中では、1つの式は、通常、
 1053: 式の意味を表す木構造の意味値を持ちます。
 1054: 
 1055: 
 1056: @node Semantic Actions, Bison Parser, Semantic Values, Concepts
 1057: @section 意味アクション
 1058: @cindex semantic actions
 1059: @cindex actions, semantic
 1060: @cindex 意味アクション
 1061: @cindex アクション
 1062: 
 1063: 役に立つようにするためには、プログラムは、入力を解析するだけでなく、
 1064: 入力に基づくなんらかの出力を生成する必要があります。
 1065: Bison文法の中では、文法規則は、
 1066: Cで書かれた@dfn{アクション(action)}を持てます。
 1067: そのルールへのマッチを構文解析器が認識するたびに、アクションが実行されます。
 1068: @xref{Actions}
 1069: 
 1070: 多くの場合に、アクションの目的は、部品の意味値から全体の意味値を
 1071: 計算することです。
 1072: たとえば、1つの式とは2つの式の和でありうると仮定します。
 1073: 構文解析器が和を認識すると、
 1074: 部分式それぞれは、それがどのように構成されたかを表す意味値を持っています。
 1075: アクションは、新しく認識された合成式について、
 1076: 同様の意味値を構成するべきです。
 1077: 
 1078: 以下に、1つの式が2つの部分式の和となる規則の例を示します。
 1079: 
 1080: @example
 1081: expr: expr '+' expr   @{ $$ = $1 + $3; @}
 1082:         ;
 1083: @end example
 1084: 
 1085: このアクションは、2個の部分式の値から、
 1086: 式の和の意味値を生成する方法を示しています。
 1087: 
 1088: 
 1089: @node Bison Parser, Stages, Semantic Actions, Concepts
 1090: @section Bisonの出力――構文解析器ファイル
 1091: @cindex Bison parser
 1092: @cindex Bison utility
 1093: @cindex lexical analyzer, purpose
 1094: @cindex parser
 1095: @cindex Bison構文解析器
 1096: @cindex Bisonユーティリティ
 1097: @cindex 字句解析器
 1098: @cindex 構文解析器
 1099: 
 1100: Bisonを使うときには、入力としてBison文法ファイルを指定します。
 1101: 文法で記述された言語を解析する、Cのソースファイルが出力になります。
 1102: このファイルを@dfn{Bison構文解析器(Bison parser)}と呼びます。
 1103: BisonユーティリティとBison構文解析器は、
 1104: 別のプログラムであることに注意してください。
 1105: Bisonユーティリティの出力がBison構文解析器で、
 1106: あなたのプログラムの一部分になるのです。
 1107: 
 1108: Bison構文解析器の仕事は、文法規則に従って、トークンをグループ化することです。
 1109: たとえば、識別子と演算子から式を組み立てます。
 1110: このために、文法規則に対応するアクションを実行します。
 1111: 
 1112: トークンは、@dfn{字句解析器(lexical analyzer)}と呼ばれる関数によって得られ、
 1113: その関数を(Cで書くような)なんらかの方法で与える必要があります。
 1114: Bison構文解析器は、新しいトークンを必要とするたびに、
 1115: 字句解析器を呼び出します。
 1116: Bison構文解析器は、トークンの「内部」がなんであるか知りません
 1117: (しかし、トークンの意味値は関係します)。
 1118: 一般に、字句解析器は、テキスト中の文字を解析してトークンを得ますが、
 1119: Bisonはその方法を知りません。
 1120: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 1121: 
 1122: Bison構文解析器ファイルは、Cのプログラムで、@code{yyparse}という名前の、
 1123: 文法を実装する関数を定義します。
 1124: この関数は、完全なCのプログラムを構成しません。
 1125: いくつかの関数を補ってやる必要があります。
 1126: 1つは、字句解析器です。
 1127: もう1つは、エラーを報告するために構文解析器が呼び出す、
 1128: エラー報告関数です。
 1129: さらに、完全なCプログラムは@code{main}関数から実行を始める必要がありますので、
 1130: これを補って、そこから@code{yyparse}を呼び出してください。
 1131: @xref{Interface, ,Parser C-Language Interface}。
 1132: 
 1133: あなたが書くアクションの中でのトークンの型名と記号に関係なく、
 1134: Bison構文解析器の中で使われるすべての変数と関数の名前は、
 1135: @samp{yy}または@samp{YY}で始まります。
 1136: これは、字句解析関数@code{yylex}とエラー報告関数@code{yyerror}および
 1137: 構文解析関数@code{yyparse}のようなインターフェイス関数も含みます。
 1138: また、内部で使われる多数の識別子も同様です。
 1139: したがって、本書で定義されている場合を除いて、
 1140: Bison文法ファイルの中で@samp{yy}または@samp{YY}で始まる
 1141: Cの識別子の利用は避けるべきです。
 1142: 
 1143: 
 1144: @node Stages, Grammar Layout, Bison Parser, Concepts
 1145: @section Bisonを使う手順
 1146: @cindex stages in using Bison
 1147: @cindex using Bison
 1148: @cindex 使用方法
 1149: @cindex Bisonの使用方法
 1150: 
 1151: Bisonを使って、文法の定義から実際に動くコンパイラやインタープリタを作るまでの、
 1152: 言語設計手順は、次のようになります。
 1153: 
 1154: @enumerate
 1155: @item
 1156: Bisonが認識できる形式で、文法を形式的に指定します
 1157: (@pxref{Grammar File, ,Bison Grammar Files})。
 1158: 言語の各文法規則に対して、
 1159: その規則のインスタンスが認識されたときに実行される
 1160: アクションを記述します。
 1161: アクションは、C言語の文の並びで書きます。
 1162: 
 1163: @item
 1164: 入力を処理し、トークンを構文解析器に渡すために、字句解析器を書きます。
 1165: 字句解析器は、Cで手作業で書いてもかまいません
 1166: (@pxref{Lexical, ,The Lexical Analyzer Function @code{yylex}})。
 1167: Lexを使って生成することも可能ですが、本書ではLexの使い方については解説
 1168: していません。
 1169: 
 1170: @item
 1171: Bisonが生成した構文解析器を呼び出す、制御関数を書きます。
 1172: 
 1173: @item
 1174: エラー報告関数を書きます。
 1175: 
 1176: @end enumerate
 1177: 
 1178: このソースプログラムを実行可能なプログラムにするために、
 1179: 次の手順が必要です。
 1180: 
 1181: @enumerate
 1182: @item
 1183: 構文解析器を生成するために、Bisonを実行します。
 1184: 
 1185: @item
 1186: Bisonが生成したソースプログラムとその他のソースプログラムを、
 1187: コンパイルします。
 1188: 
 1189: @item
 1190: オブジェクトファイルをリンクして、最終的なプログラムを得ます。
 1191: 
 1192: @end enumerate
 1193: 
 1194: 
 1195: @node Grammar Layout,  , Stages, Concepts
 1196: @section Bison文法の全体像
 1197: @cindex grammar file
 1198: @cindex file format
 1199: @cindex format of grammar file
 1200: @cindex layout of Bison grammar
 1201: @cindex 文法ファイル
 1202: @cindex ファイル書式
 1203: 
 1204: Bisonユーティリティへの入力は、
 1205: @dfn{Bison文法ファイル(Bison grammar file)}です。
 1206: Bison文法ファイルの一般的な書式は、次のとおりです。
 1207: 
 1208: @example
 1209: %@{
 1210: @var{C宣言部(C declarations)}
 1211: %@}
 1212: 
 1213: @var{Bison宣言部(Bison declarations)}
 1214: 
 1215: %%
 1216: @var{文法規則部(Grammar rules)}
 1217: %%
 1218: @var{追加のCプログラム部(Additional C code)}
 1219: @end example
 1220: 
 1221: Bison文法ファイル中の@samp{%%}、@samp{%@{}、@samp{%@}}は、
 1222: ファイルを節に分ける区切り記号です。
 1223: 
 1224: @dfn{C宣言部}では、
 1225: アクションの中で使われる型と変数を定義できます。
 1226: マクロを定義するためのプリプロセッサディレクティブや、
 1227: ヘッダファイルをインクルードするための@code{#include}命令も使用できます。
 1228: 
 1229: @dfn{Bison宣言部}には、終端記号、非終端記号、さらに、
 1230: 演算子の優先順位、さまざまな記号の意味値のデータ型を記述できます。
 1231: 
 1232: @dfn{文法規則部}では、各非終端記号をその部品から組み立てる方法を
 1233: 定義します。
 1234: 
 1235: @dfn{追加のCプログラム部}には、
 1236: あなたが望むCプログラムを記述できます。
 1237: よく字句解析関数@code{yylex}や
 1238: 文法規則の中のアクションから呼ばれる関数をここに書きます。
 1239: 単純なプログラムでは、@footnote{【訳注】他のファイルに書くのではなく}ここに
 1240: 残りのプログラム全部を書きます。
 1241: 
 1242: 
 1243: @node Examples, Grammar File, Concepts, Top
 1244: @chapter 例
 1245: @cindex simple examples
 1246: @cindex examples, simple
 1247: @cindex 単純な例
 1248: @cindex 例
 1249: 
 1250: 本章では、Bison文法を使って書いた例を3つ示します。
 1251: 逆ポーランド記法電卓、算術(中置)記法電卓、多機能電卓です。
 1252: すべてBSD UNIX 4.3上でテストしました。
 1253: 限定的ではありますが、対話的な電卓として利用可能です。
 1254: 
 1255: これらの例は単純ですが、現実のプログラミング言語に対する
 1256: Bison文法も、書き方は同じです。
 1257: 
 1258: @ifinfo
 1259: これらの例をInfoファイルから取り出してソースファイルにコピーし、
 1260: 試すことができます。
 1261: @end ifinfo
 1262: 
 1263: @menu
 1264: * RPN Calc::          逆ポーランド記法電卓;
 1265:                         演算子の優先順位が無い、最初の例.
 1266: * Infix Calc::        中間(代数)記法電卓.
 1267:                         演算子の優先順位が導入された.
 1268: * Simple Error Recovery::  構文エラーの後も続行する.
 1269: * Multi-function Calc::  メモリと三角関数付きの電卓.
 1270:                            意味値に複数のデータ型を使用する.
 1271: * Exercises::         多機能電卓を改善するための着想.
 1272: @end menu
 1273: 
 1274: 
 1275: @node RPN Calc, Infix Calc,  , Examples
 1276: @section 逆ポーランド記法電卓
 1277: @cindex reverse polish notation
 1278: @cindex polish notation calculator
 1279: @cindex rpcalc
 1280: @cindex calculator, simple
 1281: @cindex 逆ポーランド記法
 1282: @cindex 電卓
 1283: 
 1284: 最初の例は、@dfn{逆ポーランド記法(reverse polish notation)}を使う
 1285: 倍精度の電卓で、演算子を後に書きます。
 1286: この例は、演算子の優先順位の問題がないので、入門には適しています。
 1287: 第2の例では、演算子の優先順位をどのように扱うかを示します。
 1288: 
 1289: この電卓のソースファイルを@file{rpcalc.y}とします。
 1290: Bisonの入力ファイルには、通常@samp{.y}という拡張子を付けます。
 1291: 
 1292: @menu
 1293: * Decls: Rpcalc Decls.  rpcalcのためのBisonとCの宣言.
 1294: * Rules: Rpcalc Rules.  rpcalcのための文法規則。説明付き.
 1295: * Lexer: Rpcalc Lexer.  字句解析器.
 1296: * Main: Rpcalc Main.    制御関数.
 1297: * Error: Rpcalc Error.  エラー報告関数.
 1298: * Gen: Rpcalc Gen.      文法ファイルでBisonを実行する.
 1299: * Comp: Rpcalc Compile. 出力コードにCコンパイラを実行する.
 1300: @end menu
 1301: 
 1302: 
 1303: @node Rpcalc Decls, Rpcalc Rules,  , RPN Calc
 1304: @subsection @code{rpcalc}のための宣言
 1305: 
 1306: 逆ポーランド記法電卓のためのCとBisonの宣言を示します。
 1307: Cと同様に@samp{/*@dots{}*/}はコメントです。
 1308: 
 1309: @example
 1310: /* 逆ポーランド記法電卓 */
 1311: 
 1312: %@{
 1313: #define YYSTYPE double
 1314: #include <math.h>
 1315: %@}
 1316: 
 1317: %token NUM
 1318: 
 1319: %% /* 文法規則とアクションが続く */
 1320: @end example
 1321: 
 1322: C宣言部(@pxref{C Declarations, ,The C Declarations Section})には、
 1323: 2つのプリプロセッサディレクティブがあります。
 1324: 
 1325: @code{#define}ディレクティブで、トークンとグループの意味値に対する
 1326: Cのデータ型を指定するために、マクロ@code{YYSTYPE}を定義します
 1327: (@pxref{Value Type, ,Data Types of Semantic Values})。
 1328: Bison構文解析器は、@code{YYSTYPE}に定義された型を使います。
 1329: 定義しないと、@code{int}型が使用されます。
 1330: 各トークンと式は、浮動小数点数である記録値を持つので、
 1331: ここでは@code{double}を指定します。
 1332: 
 1333: べき乗関数@code{pow}の宣言を使うために、
 1334: @code{#include}ディレクティブを使っています。
 1335: 
 1336: 第2の部、Bison宣言は、Bisonのためにトークン型についての情報を用意します
 1337: (@pxref{Bison Declarations, ,The Bison Declarations Section})。
 1338: 1文字リテラルでない終端記号は、ここで宣言する必要があります
 1339: (通常、1文字のリテラルを宣言する必要はありません)。
 1340: この例では、すべての算術演算子が1文字リテラルなので、
 1341: 数値定数に対するトークン型@code{NUM}だけを、
 1342: 終端記号として宣言します。
 1343: 
 1344: 
 1345: @node Rpcalc Rules, Rpcalc Lexer, Rpcalc Decls, RPN Calc
 1346: @subsection @code{rpcalc}のための文法規則
 1347: 
 1348: 逆ポーランド記法電卓のための文法規則を示します。
 1349: 
 1350: @example
 1351: input:    /* 空 */
 1352:         | input line
 1353: ;
 1354: 
 1355: line:     '\n'
 1356:         | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
 1357: ;
 1358: 
 1359: exp:      NUM             @{ $$ = $1;         @}
 1360:         | exp exp '+'     @{ $$ = $1 + $2;    @}
 1361:         | exp exp '-'     @{ $$ = $1 - $2;    @}
 1362:         | exp exp '*'     @{ $$ = $1 * $2;    @}
 1363:         | exp exp '/'     @{ $$ = $1 / $2;    @}
 1364:       /* べき乗関数 */
 1365:         | exp exp '^'     @{ $$ = pow ($1, $2); @}
 1366:       /* 単項のマイナス    */
 1367:         | exp 'n'         @{ $$ = -$1;        @}
 1368: ;
 1369: %%
 1370: @end example
 1371: 
 1372: ここで定義されるrpcalc「言語」のグループは、
 1373: 式(@code{exp})と、入力行(@code{line})と、
 1374: 完全な入力の写し(@code{input})です。
 1375: これらの非終端記号には、「論理和」という@samp{|}記号で区切られた、
 1376: いくつかの規則があります。
 1377: 以下の項で、これらの規則の意味を説明します。
 1378: 
 1379: 言語の意味は、グループが認識されたときのアクションによって決まります。
 1380: アクションとは、ブレースで囲まれたCのプログラムです。
 1381: @xref{Actions}。
 1382: 
 1383: これらのアクションをCで書く必要がありますが、
 1384: Bisonには規則の間で意味値を受け渡しする方法があります。
 1385: それぞれのアクションで、擬似変数@code{$$}は、
 1386: その規則が構成しようとしているグループの意味値を示します。
 1387: @code{$$}に値を代入することが、アクションの主な仕事です。
 1388: 規則の部品の意味値は、@code{$1}、@code{$2}などの
 1389: 名前で参照されます。
 1390: 
 1391: @menu
 1392: * Rpcalc Input::      
 1393: * Rpcalc Line::       
 1394: * Rpcalc Expr::       
 1395: @end menu
 1396: 
 1397: 
 1398: @node Rpcalc Input, Rpcalc Line,  , Rpcalc Rules
 1399: @subsubsection @code{input}の説明
 1400: 
 1401: @code{input}の定義について考えます。
 1402: 
 1403: @example
 1404: input:    /* 空 */
 1405:         | input line
 1406: ;
 1407: @end example
 1408: 
 1409: この定義の意味は、「完全な入力とは、空文字列であるか、あるいは、
 1410: 完全な入力に入力行が続いたものである」ということです。
 1411: 「完全な入力」が、それ自身を使って定義されていることに注意してください。
 1412: 列の中で@code{input}が常に左端の記号なので、
 1413: このような定義を@dfn{左再帰(left recursive)}と呼びます。
 1414: @xref{Recursion, ,Recursive Rules}。
 1415: 
 1416: 最初の選択肢は、@samp{:}と@samp{|}の間に記号がないので空です。
 1417: これは、(トークンを含まない)空の入力文字列にマッチします。
 1418: 電卓を起動した直後に@kbd{Ctrl-d} @footnote{【訳注】UNIXの標準的なコンソールの
 1419: 設定で、入力の終わりを示す制御文字で、MS-DOSでは代わりに@kbd{Ctrl-z}。}を
 1420: 押しても、正しい入力と扱われるように、この規則を入れました。
 1421: 通常、空に対応する選択肢を最初に置き、そこに@samp{/* 空 */}と
 1422: 書きます。
 1423: 
 1424: 2つめの選択肢である規則(@code{input line})は、
 1425: 自明(空)でないすべての入力を扱います。
 1426: その意味は、「任意の数の行を読み込んだ後で、もし可能ならば、
 1427: もう1行読み込む」ということです。
 1428: 左再帰が、この規則を繰り返しにします。
 1429: 最初の選択肢が空の入力にマッチするので、
 1430: 0回以上任意の回数の繰り返しになります。
 1431: 
 1432: 構文解析器関数@code{yyparse}は、文法エラーが発生するか、あるいは、
 1433: 字句解析器がもうトークンがないと判定するまで、
 1434: 入力の処理を続けます。
 1435: ファイルの終わりで起きることについては、後で考慮します。
 1436: 
 1437: 
 1438: @node Rpcalc Line, Rpcalc Expr, Rpcalc Input, Rpcalc Rules
 1439: @subsubsection @code{line}の説明
 1440: 
 1441: 次に、@code{line}の定義について考えます。
 1442: 
 1443: @example
 1444: line:     '\n'
 1445:         | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
 1446: ;
 1447: @end example
 1448: 
 1449: 最初の選択肢は、改行文字であるトークンです。
 1450: これは、rpcalcが空行を受け入れ、それに対応するアクションがないので、
 1451: 無視することを示します。
 1452: 第2の選択肢は、式の後に改行が続いたものです。
 1453: これが、rpcalcを有用にする選択肢です。
 1454: 問い合わせの中の@code{exp}が、この選択肢に現れる最初の記号なので、
 1455: @code{exp}グループの意味値は、@code{$1}の値です。
 1456: アクションは、問い合わされた計算の結果である、
 1457: この値を表示します。
 1458: 
 1459: このアクションは、値を@code{$$}に代入しないので、例外的です。
 1460: したがって、@code{line}に対応する意味値は、初期化されず、
 1461: その値は予想できなくなります。
 1462: もし、その値が使われると、この仕様はバグになりますが、われわれはこの値を使い
 1463: ません。ユーザーが入力した行に対する値を表示したら、
 1464: その値はもはや必要ありません。
 1465: 
 1466: 
 1467: @node Rpcalc Expr,  , Rpcalc Line, Rpcalc Rules
 1468: @subsubsection @code{expr}の説明
 1469: 
 1470: @code{exp}グループは、いくつかの規則を持ち、
 1471: それぞれが式の種類に対応しています。
 1472: 最初の規則は、数値そのものであるもっとも単純な式を処理します。
 1473: 第2の規則は、2個の式に加算記号が続くような、加算式を処理します。
 1474: 第3の規則は、減算式を処理する、といった具合です。
 1475: 
 1476: @example
 1477: exp:      NUM
 1478:         | exp exp '+'     @{ $$ = $1 + $2;    @}
 1479:         | exp exp '-'     @{ $$ = $1 - $2;    @}
 1480:         @dots{}
 1481:         ;
 1482: @end example
 1483: 
 1484: すべての@code{exp}規則をまとめるために@samp{|}を使っていますが、
 1485: 次のように別々に書くことも可能です。
 1486: 
 1487: @example
 1488: exp:      NUM ;
 1489: exp:      exp exp '+'     @{ $$ = $1 + $2;    @} ;
 1490: exp:      exp exp '-'     @{ $$ = $1 - $2;    @} ;
 1491:         @dots{}
 1492: @end example
 1493: 
 1494: 規則のほとんどは、式の部品の値から式の値を計算するための、
 1495: アクションを持っています。
 1496: たとえば、加算のための規則では、@code{$1}は式の第1の部品を、
 1497: @code{$2}は式の第2の部品を表します。
 1498: 第3の部品@code{'+'}は、意味値には関連する情報を持ちませんが、
 1499: もし値を持っていれば、@code{$3}として参照できます。
 1500: @code{yyparse}がこの規則を使って加算式を認識すると、
 1501: 式全体の値として、2個の部分式の値の和が生成されます。
 1502: @xref{Actions}。
 1503: 
 1504: すべての規則に対してアクションを書く必要はありません。
 1505: アクションを省略すると、Bisonは@code{$1}の値を@code{$$}に複写します。
 1506: 第1の規則では、@code{NUM}の値をそのまま複写するために、
 1507: このようになっています。
 1508: 
 1509: ここで示したリストは、望ましい書式ですが、
 1510: Bisonがこのように要求するわけではありません。
 1511: 必要に応じて、空白、タブ、改行を置けます。
 1512: 次のような書き方も可能です。
 1513: 
 1514: @example
 1515: exp   : NUM | exp exp '+' @{$$ = $1 + $2; @} | @dots{}
 1516: @end example
 1517: 
 1518: これは、次のリストと等価です。
 1519: 
 1520: @example
 1521: exp:      NUM
 1522:         | exp exp '+'    @{ $$ = $1 + $2; @}
 1523:         | @dots{}
 1524: @end example
 1525: 
 1526: しかし、後者のほうが可読性が優れています。
 1527: 
 1528: 
 1529: @node Rpcalc Lexer, Rpcalc Main, Rpcalc Rules, RPN Calc
 1530: @subsection @code{rpcalc}字句解析器
 1531: @cindex writing a lexical analyzer
 1532: @cindex lexical analyzer, writing
 1533: @cindex 字句解析器
 1534: 
 1535: 字句解析器の仕事は、低水準の構文解析で、文字または文字列を
 1536: トークンに変換します。
 1537: Bison構文解析器は、字句解析器を呼び出してトークンを得ます。
 1538: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 1539: 
 1540: RPN(逆ポーランド記法)電卓には、簡単な字句解析器のみが必要です。
 1541: この字句解析器は、空白とタブを読み飛ばし、
 1542: 数値を読み込んで@code{double}型の@code{NUM}トークンとして返します。
 1543: 数値の一部分ではないその他の文字は、独立のトークンです。
 1544: 1文字トークンのトークン符号はその文字自身であることに注意してください。
 1545: 
 1546: 字句解析関数の戻り値は、トークン型を表す数値です。
 1547: Bison規則の中でトークン型を表すために使われる文字列と同じものが、
 1548: その型の数値符号を表すCの式でもあります。
 1549: これには、2種類の働きがあります。
 1550: もし、トークン型が文字リテラルならば、
 1551: その数値符号は文字のASCII符号であり、
 1552: 数値を表すために字句解析器の中と同じ文字リテラルを使えます。
 1553: もし、トークン型が識別子ならば、適切な番号を定義するCのマクロとして、
 1554: その識別子がBisonによって定義されます。
 1555: したがって、この例では、@code{NUM}は、@code{yylex}のために使える
 1556: マクロにもなります。
 1557: 
 1558: トークンの意味値は、もし存在すれば、大域変数@code{yylval}に記憶され、
 1559: Bison構文解析器はそこを見にいきます
 1560: (@code{yylval}のCデータ型は、文法の最初で定義される@code{YYSTYPE}です。
 1561: @pxref{Rpcalc Decls, ,Declarations for @code{rpcalc}})。
 1562: 
 1563: ファイルの終わりに達すると、トークン型のコード0が返されます
 1564: (Bisonは、正でない任意の値を入力の終わりと認識します)。
 1565: 
 1566: 字句解析器のプログラムの例を示します。
 1567: 
 1568: @example
 1569: @group
 1570: /*
 1571:  * 字句解析器は、数値を読めば、double型の値をスタックに積んで
 1572:  * トークン「NUM」を返し、数値以外を読めば、その文字のアスキー符号を返す。
 1573:  * 空白とタブは読み飛ばされる。ファイルが終わると0を返す。
 1574:  */
 1575: 
 1576: #include <ctype.h>
 1577: @end group
 1578: 
 1579: @group
 1580: yylex ()
 1581: @{
 1582:   int c;
 1583: 
 1584:   /* 空白類を読み飛ばす  */
 1585:   while ((c = getchar ()) == ' ' || c == '\t')  
 1586:     ;
 1587: @end group
 1588: @group
 1589:   /* 数値を処理する   */
 1590:   if (c == '.' || isdigit (c))                
 1591:     @{
 1592:       ungetc (c, stdin);
 1593:       scanf ("%lf", &yylval);
 1594:       return NUM;
 1595:     @}
 1596: @end group
 1597: @group
 1598:   /* ファイルの終わりを処理する  */
 1599:   if (c == EOF)                            
 1600:     return 0;
 1601:   /* 1文字を返す */
 1602:   return c;                                
 1603: @}
 1604: @end group
 1605: @end example
 1606: 
 1607: 
 1608: @node Rpcalc Main, Rpcalc Error, Rpcalc Lexer, RPN Calc
 1609: @subsection 制御関数
 1610: @cindex controlling function
 1611: @cindex main function in simple example
 1612: @cindex 制御関数
 1613: @cindex 単純な例のmain関数
 1614: @cindex main関数
 1615: 
 1616: この例の精神に則って、制御関数は、飾りのない最小限のものです。
 1617: 唯一必要なことは、構文解析の処理を始めるために、
 1618: @code{yyparse}関数を呼び出すことです。
 1619: 
 1620: @example
 1621: @group
 1622: main ()
 1623: @{
 1624:   yyparse ();
 1625: @}
 1626: @end group
 1627: @end example
 1628: 
 1629: @footnote{【訳注】古いK&R-C処理系を使う場合には前述の例のままでよいのですが、
 1630: ANSI-C処理系を使う場合には、@code{main}関数が返す値が
 1631: @code{int}型なので、次のように書くべきです。
 1632: 他の関数についても同様です。本書の例のすべては古い書式で書かれています。
 1633: 
 1634: @example
 1635: @group
 1636: int main ()
 1637: @{
 1638:   return yyparse ();
 1639: @}
 1640: @end group
 1641: @end example
 1642: }
 1643: 
 1644: @node Rpcalc Error, Rpcalc Gen, Rpcalc Main, RPN Calc
 1645: @subsection エラー報告関数
 1646: @cindex error reporting routine
 1647: @cindex エラー報告関数
 1648: 
 1649: @code{yyparse}は、構文エラーを検出すると、エラーメッセージ
 1650: (必ずそうとはかぎりませんが、通常は@code{"parse error"})を
 1651: 表示するために、エラー報告関数@code{yyerror}を呼び出します。
 1652: 
 1653: @example
 1654: @group
 1655: #include <stdio.h>
 1656: 
 1657: yyerror (s)  /* エラーが起きるとyyparseから呼び出される */
 1658:      char *s;
 1659: @{
 1660:   printf ("%s\n", s);
 1661: @}
 1662: @end group
 1663: @end example
 1664: 
 1665: @code{yyerror}から戻った後に、Bison構文解析器は、
 1666: 文法に適切なエラー規則(@pxref{Error Recovery})があれば、
 1667: エラーから回復し、解析を継続できます。
 1668: そうでない場合には、@code{yyparse}が0でない値を返します。
 1669: この例では、エラー規則を書いていないので、
 1670: 不正な入力はすべて電卓プログラムを終了させます。
 1671: これは、実際の電卓としてはきれいな動作ではありませんが、
 1672: 最初の例としては十分です。
 1673: 
 1674: 
 1675: @node Rpcalc Gen, Rpcalc Compile, Rpcalc Error, RPN Calc
 1676: @subsection 構文解析器を生成するためにBisonを実行
 1677: @cindex running Bison (introduction)
 1678: @cindex Bisonの実行
 1679: 
 1680: 構文解析器を生成するためにBisonを実行する前に、
 1681: 1つ以上のソースファイルのすべてをどのように整えるか、
 1682: 決める必要があります。
 1683: このような単純な例では、すべてを1個のファイルに詰め込む方法が
 1684: いちばん簡単です。
 1685: @code{yylex}、@code{yyerror}、@code{main}の定義を、
 1686: ファイルの「追加のCコード」部の最後に置きます
 1687: (@pxref{Grammar Layout, ,The Overall Layout of a Bison Grammar})。
 1688: 
 1689: 大きなプロジェクトでは、ソースコードを複数のファイルに分け、
 1690: まとめてリコンパイルするために@code{make}を使うでしょう。
 1691: 
 1692: 1つのファイルにすべてのソースが入っているならば、
 1693: 次のコマンドで、それを構文解析器ファイルに変換できます。
 1694: 
 1695: @example
 1696: bison @var{file_name}.y
 1697: @end example
 1698: 
 1699: この例では、ファイルは@file{rpcalc.y}(逆ポーランド記法電卓)と
 1700: 呼ばれています。Bisonは、元のファイル名から@samp{.y}を取り除いて、
 1701: @file{@var{file_name}.tab.c}というファイルを生成します。
 1702: Bisonが出力したファイルには、@code{yyparse}のソースコードが含まれています。
 1703: 入力ファイル中の追加の関数(@code{yylex}、@code{yyerror}、@code{main})は、
 1704: 出力にそのまま複写されます。
 1705: 
 1706: 
 1707: @node Rpcalc Compile,  , Rpcalc Gen, RPN Calc
 1708: @subsection 構文解析器ファイルのコンパイル
 1709: @cindex compiling the parser
 1710: @cindex コンパイル
 1711: 
 1712: 構文解析器ファイルをコンパイルする方法を示します。
 1713: @footnote{【訳注】UNIX上で@code{cc}コマンドを使ってコンパイルする方法を示します。}
 1714: 
 1715: @example
 1716: @group
 1717: # @r{カレントディレクトリのファイルの一覧を見る。}
 1718: % ls
 1719: rpcalc.tab.c  rpcalc.y
 1720: @end group
 1721: 
 1722: @group
 1723: # @r{Bison構文解析器をコンパイルする。}
 1724: # @r{数学ライブラリ内の@code{pow}関数をリンクするために@samp{-lm}を指定する。}
 1725: % cc rpcalc.tab.c -lm -o rpcalc
 1726: @end group
 1727: 
 1728: @group
 1729: # @r{再び、ファイルの一覧を見る。}
 1730: % ls
 1731: rpcalc  rpcalc.tab.c  rpcalc.y
 1732: @end group
 1733: @end example
 1734: 
 1735: できた@file{rpcalc}ファイルは、実行可能プログラムです。
 1736: @code{rpcalc}を実行させる例を示します。
 1737: 
 1738: @example
 1739: % rpcalc
 1740: 4 9 +
 1741: 13
 1742: 3 7 + 3 4 5 *+-
 1743: -13
 1744: 3 7 + 3 4 5 * + - n              @r{単項マイナスを示す@samp{n}に注意}
 1745: 13
 1746: 5 6 / 4 n +
 1747: -3.166666667
 1748: 3 4 ^                            @r{べき乗関数}
 1749: 81
 1750: ^D                               @r{入力の終わり}
 1751: %
 1752: @end example
 1753: 
 1754: 
 1755: @node Infix Calc, Simple Error Recovery, RPN Calc, Examples
 1756: @section 中間記法電卓:@code{calc}
 1757: @cindex infix notation calculator
 1758: @cindex calc
 1759: @cindex calculator, infix notation
 1760: @cindex 中間記法
 1761: 
 1762: 後置記法演算子に代わって中間記法演算子を扱うように
 1763: rpcalcを変更します。
 1764: 中間記法には、演算子の優先順位の概念と、
 1765: 適切な深さに入れ子できるかっこが必要です。
 1766: 中間記法電卓を作るためのBisonソースファイル
 1767: @file{calc.y}を示します。
 1768: 
 1769: @example
 1770: /* 中間記法電卓 -- calc */
 1771: 
 1772: %@{
 1773: #define YYSTYPE double
 1774: #include <math.h>
 1775: %@}
 1776: 
 1777: /* BISON宣言 */
 1778: %token NUM
 1779: %left '-' '+'
 1780: %left '*' '/'
 1781: %left NEG     /* negation--単項マイナス */
 1782: %right '^'    /* べき乗関数        */
 1783: 
 1784: /* 文法規則が続く */
 1785: %%
 1786: input:    /* 空文字列 */
 1787:         | input line
 1788: ;
 1789: 
 1790: line:     '\n'
 1791:         | exp '\n'  @{ printf ("\t%.10g\n", $1); @}
 1792: ;
 1793: 
 1794: exp:      NUM                @{ $$ = $1;         @}
 1795:         | exp '+' exp        @{ $$ = $1 + $3;    @}
 1796:         | exp '-' exp        @{ $$ = $1 - $3;    @}
 1797:         | exp '*' exp        @{ $$ = $1 * $3;    @}
 1798:         | exp '/' exp        @{ $$ = $1 / $3;    @}
 1799:         | '-' exp  %prec NEG @{ $$ = -$2;        @}
 1800:         | exp '^' exp        @{ $$ = pow ($1, $3); @}
 1801:         | '(' exp ')'        @{ $$ = $2;         @}
 1802: ;
 1803: %%
 1804: @end example
 1805: 
 1806: @code{yylex}、@code{yyerror}、@code{main}関数は、
 1807: 前の例のものと同じです。
 1808: 
 1809: このプログラムには、2つの重要な特徴があります。
 1810: 
 1811: 第2の部分(Bison宣言部)では、
 1812: @code{%left}がトークンの型とそれが左結合演算子であると宣言します。
 1813: 宣言@code{%left}と@code{%right}(右結合演算子)は、
 1814: 結合性を持たないトークン型名を宣言するために使われる@code{%token}の代わりに
 1815: なります
 1816: (1文字のリテラルであるトークンは、通常、宣言する必要がありません。
 1817: ここでは、結合性を宣言します)。
 1818: 
 1819: 演算子の優先順位は、宣言が書かれる行の順序で決まります。
 1820: 後から宣言された演算子ほど、高い優先順位を持ちます。
 1821: したがって、べき乗の優先順位がもっとも高く、
 1822: 単項の負(@code{NEG})、「@samp{*}」と「@samp{/}」と続きます。
 1823: @xref{Precedence, ,Operator Precedence}。
 1824: 
 1825: もう1つの重要な特徴は、単項の負の演算子のために文法部分にある
 1826: @code{%prec}です。
 1827: @code{%prec}は、単純にBisonに対して、規則@samp{| '-' exp}は
 1828: @code{NEG}と同じ優先順位を持つように指示し、
 1829: この例ではどちらも2番目に高い優先順位を持ちます。
 1830: 
 1831: 以下は@file{calc.y}の実行例です。
 1832: 
 1833: @need 500
 1834: @example
 1835: % calc
 1836: 4 + 4.5 - (34/(8*3+-3))
 1837: 6.880952381
 1838: -56 + 2
 1839: -54
 1840: 3 ^ 2
 1841: 9
 1842: @end example
 1843: 
 1844: 
 1845: @node Simple Error Recovery, Multi-function Calc, Infix Calc, Examples
 1846: @section 単純なエラー回復
 1847: @cindex error recovery, simple
 1848: @cindex エラー回復
 1849: 
 1850: 今まで、本書では、@dfn{エラー回復(error recovery)}、
 1851: つまり、構文エラーを検出した後で構文解析を続ける方法については
 1852: 言及していませんでした。
 1853: 今までに扱ったことは、@code{yyerror}を使ってエラーを報告することだけでした。
 1854: @code{yyerror}を呼び出した後で、特に指定しないと@code{yyparse}は
 1855: 処理を終わることを思い出してください。
 1856: つまり、エラーを含む入力行が、電卓プログラムを終了させます。
 1857: この欠陥をどのように改善するか示しましょう。
 1858: 
 1859: Bison言語の文法規則には、予約語@code{error}があります。
 1860: 次の例では、@code{line}に対する選択肢群に@code{error}を追加する
 1861: 方法を示します。
 1862: 
 1863: @example
 1864: @group
 1865: line:     '\n'
 1866:         | exp '\n'   @{ printf ("\t%.10g\n", $1); @}
 1867:         | error '\n' @{ yyerrok;                  @}
 1868: ;
 1869: @end group
 1870: @end example
 1871: 
 1872: 文法へのこの追加によって、構文解析エラーが発生した場合に、
 1873: 簡単なエラー回復が可能になります。
 1874: 評価不可能な式が読み込まれると、
 1875: @code{line}に対する第3の規則によってエラーが認識され、
 1876: 構文解析が続けられます。
 1877: この場合にも、関数@code{yyerror}は呼び出され、
 1878: メッセージを表示します。
 1879: アクションは、
 1880: Bisonによって自動的に定義されるマクロである@code{yyerrok}文を実行します。
 1881: これはエラー回復の完了を意味します(@pxref{Error Recovery})。
 1882: @code{yyerrok}と@code{yyerror}の違いに注意してください。
 1883: 
 1884: この形式のエラー回復は、構文エラーを扱います。
 1885: 他の種類のエラーもあります。
 1886: たとえば、0による除算は、例外シグナルを発生し、通常は致命的です。
 1887: 実際の電卓プログラムは、このシグナルをつかまえて、@code{longjmp}を使って
 1888: @code{main}に戻り、入力行の構文解析を続ける必要があります。
 1889: さらに、現在の入力行の残りは破棄されるべきです。
 1890: しかし、これらの問題は、Bisonのプログラムに固有の問題ではないので、
 1891: 本書では解説しません。
 1892: 
 1893: 
 1894: @node Multi-function Calc, Exercises, Simple Error Recovery, Examples
 1895: @section 多機能電卓:@code{mfcalc}
 1896: @cindex multi-function calculator
 1897: @cindex mfcalc
 1898: @cindex calculator, multi-function
 1899: @cindex 多機能電卓
 1900: @cindex 電卓, 多機能
 1901: 
 1902: Bisonの基礎についての説明が終わったので、より高度な話題に移りましょう。
 1903: 前述の電卓は、5種類の機能、@samp{+}、@samp{-}、@samp{*}、@samp{/}、
 1904: @samp{^}を持っています。
 1905: この電卓に、その他の数学関数、たとえば、@code{sin}、@code{cos}などを
 1906: 追加するとよいでしょう。
 1907: 
 1908: 中間記法電卓への新しい演算子の追加は、
 1909: その演算子が1文字リテラルならば簡単です。
 1910: 字句解析器@code{yylex}は、数値以外のすべての文字をトークンとして渡すので、
 1911: 追加の演算子に対応する文法規則を追加するだけです。
 1912: しかし、次のような表記方法の、より柔軟な組み込み関数が必要です。
 1913: 
 1914: @example
 1915: @var{関数名} (@var{引数})
 1916: @end example
 1917: 
 1918: さらに、電卓にメモリを追加し、名前付き変数を作り、そこに値を記憶し、
 1919: 後で使えるようにしましょう。
 1920: 以下に多機能電卓を使う作業の例を示します。
 1921: 
 1922: @example
 1923: % mfcalc
 1924: pi = 3.141592653589
 1925: 3.1415926536
 1926: sin(pi)
 1927: 0.0000000000
 1928: alpha = beta1 = 2.3
 1929: 2.3000000000
 1930: alpha
 1931: 2.3000000000
 1932: ln(alpha)
 1933: 0.8329091229
 1934: exp(ln(beta1))
 1935: 2.3000000000
 1936: %
 1937: @end example
 1938: 
 1939: 
 1940: 複数の代入@footnote{【訳注】例の@samp{alpha = beta1 = 2.3}}と
 1941: 関数の入れ子@footnote{【訳注】例の@samp{exp(ln(beta1))}}が
 1942: 許されることに注意してください。
 1943: 
 1944: @menu
 1945: * Decl: Mfcalc Decl.      多機能電卓のためのBisonの宣言.
 1946: * Rules: Mfcalc Rules.    電卓のための文法規則.
 1947: * Symtab: Mfcalc Symtab.  記号表を管理するサブルーチン.
 1948: @end menu
 1949: 
 1950: 
 1951: @node Mfcalc Decl, Mfcalc Rules,  , Multi-function Calc
 1952: @subsection @code{mfcalc}のための定義
 1953: 
 1954: 以下には、多機能電卓のための、CとBisonの宣言があります。
 1955: 
 1956: @smallexample
 1957: %@{
 1958: #include <math.h>  /* cos(), sin()などの数学関数のため */
 1959: #include "calc.h"  /* `symrec'の定義を含む             */
 1960: %@}
 1961: %union @{
 1962: double     val;    /* 数値を返すため                   */
 1963: symrec  *tptr;     /* 記号表へのポインタを返すため     */
 1964: @}
 1965: 
 1966: %token <val>  NUM        /* 単純な倍精度数値 */
 1967: %token <tptr> VAR FNCT   /* 変数と関数       */
 1968: %type  <val>  exp
 1969: 
 1970: %right '='
 1971: %left '-' '+'
 1972: %left '*' '/'
 1973: %left NEG     /* 否定 -- 単項の負 */
 1974: %right '^'    /* べき乗           */
 1975: 
 1976: /* 文法が続く */
 1977: 
 1978: %%
 1979: @end smallexample
 1980: 
 1981: この文法の導入部分では、Bison言語の新しい2つの機能を使っています。
 1982: これらの機能によって、意味値がいろいろなデータ型を持てます
 1983: (@pxref{Multiple Types, ,More Than One Value Type})。
 1984: 
 1985: @code{%union}宣言は、@code{YYSTYPE}の定義の代わりで、
 1986: 可能な型の一覧を指定します。
 1987: ここで許される型は、(@code{exp}と@code{NUM}のための)倍精度浮動小数点型と、
 1988: 記号表の項目へのポインタです。
 1989: @xref{Union Decl, ,The Collection of Value Types}。
 1990: 
 1991: 値がいろいろな型を持つことができるので、
 1992: 意味値を使うそれぞれの文法記号に対して、
 1993: 型を関連づける必要があります。
 1994: これらの記号は@code{NUM}、@code{VAR}、@code{FNCT}、@code{exp}です。
 1995: それらの宣言は、不等号で囲まれた(@samp{<...>})データ型に関する
 1996: 情報を付加されています。
 1997: 
 1998: Bisonは、ちょうど@code{%token}がトークン型の宣言に使われるのと同じように、
 1999: @code{%type}が非終端記号の宣言に使われるようにします。
 2000: 非終端記号は通常それらを定義する規則によって暗黙に宣言されるので、
 2001: @code{%type}をその規則よりも先に使ってはいけません。
 2002: しかし、@code{exp}は、その値の型を指定するので、
 2003: 明示的に宣言する必要があります。
 2004: @xref{Type Decl, ,Nonterminal Symbols}。
 2005: 
 2006: 
 2007: @node Mfcalc Rules, Mfcalc Symtab, Mfcalc Decl, Multi-function Calc
 2008: @subsection @code{mfcalc}のための文法規則
 2009: 
 2010: 多機能電卓のための文法規則を示します。
 2011: 大部分は、@code{calc}の文法規則からの複写です。
 2012: @code{VAR}、@code{FUNCT}に関連する3つの規則が新しいものです。
 2013: 
 2014: @smallexample
 2015: input:   /* 空 */
 2016:         | input line
 2017: ;
 2018: 
 2019: line:
 2020:           '\n'
 2021:         | exp '\n'   @{ printf ("\t%.10g\n", $1); @}
 2022:         | error '\n' @{ yyerrok;                  @}
 2023: ;
 2024: 
 2025: exp:      NUM                @{ $$ = $1;                         @}
 2026:         | VAR                @{ $$ = $1->value.var;              @}
 2027:         | VAR '=' exp        @{ $$ = $3; $1->value.var = $3;     @}
 2028:         | FNCT '(' exp ')'   @{ $$ = (*($1->value.fnctptr))($3); @}
 2029:         | exp '+' exp        @{ $$ = $1 + $3;                    @}
 2030:         | exp '-' exp        @{ $$ = $1 - $3;                    @}
 2031:         | exp '*' exp        @{ $$ = $1 * $3;                    @}
 2032:         | exp '/' exp        @{ $$ = $1 / $3;                    @}
 2033:         | '-' exp  %prec NEG @{ $$ = -$2;                        @}
 2034:         | exp '^' exp        @{ $$ = pow ($1, $3);               @}
 2035:         | '(' exp ')'        @{ $$ = $2;                         @}
 2036: ;
 2037: /* 文法の終わり */
 2038: %%
 2039: @end smallexample
 2040: 
 2041: 
 2042: @node Mfcalc Symtab,  , Mfcalc Rules, Multi-function Calc
 2043: @subsection @code{mfcalc}の記号表
 2044: @cindex symbol table example
 2045: @cindex 記号表の例
 2046: 
 2047: 変数と関数の名前と意味を保持するために、
 2048: 多機能電卓は記号表を必要とします。
 2049: これは、アクションを除く文法規則とBison宣言には影響しませんが、
 2050: 追加のCの関数がいくつか必要です。
 2051: 
 2052: 記号表は、レコードのリンクリストからなります。
 2053: その定義は、後述の、ヘッダファイル@file{calc.h}にあります。
 2054: 関数と変数の両方を表に置くことができます。
 2055: 
 2056: @smallexample
 2057: @group
 2058: /* 記号表のリンクを表すデータ型                 */
 2059: struct symrec
 2060: @{
 2061:   char *name;  /* 記号の名前                    */
 2062:   int type;    /* 記号の種類:VARまたはFNCT     */
 2063:   union @{
 2064:     double var;           /* VARの値            */
 2065:     double (*fnctptr)();  /* FNCTの値           */
 2066:   @} value;
 2067:   struct symrec *next;    /* 次の項目へのリンク */
 2068: @};
 2069: @end group
 2070: 
 2071: @group
 2072: typedef struct symrec symrec;
 2073: 
 2074: /* `struct symrec'のリンクである記号表          */
 2075: extern symrec *sym_table;
 2076: 
 2077: symrec *putsym ();
 2078: symrec *getsym ();
 2079: @end group
 2080: @end smallexample
 2081: 
 2082: 新しい@code{main}関数は、記号表を初期化する関数である
 2083: @code{init_table}を呼びます。
 2084: @code{main}と@code{init_table}を以下に示します。
 2085: 
 2086: @smallexample
 2087: @group
 2088: #include <stdio.h>
 2089: 
 2090: main ()
 2091: @{
 2092:   init_table ();
 2093:   yyparse ();
 2094: @}
 2095: @end group
 2096: 
 2097: @group
 2098: yyerror (s)  /* エラーがあるとyyparseから呼び出される */
 2099:      char *s;
 2100: @{
 2101:   printf ("%s\n", s);
 2102: @}
 2103: 
 2104: struct init
 2105: @{
 2106:   char *fname;
 2107:   double (*fnct)();
 2108: @};
 2109: @end group
 2110: 
 2111: @group
 2112: struct init arith_fncts[]
 2113:   = @{
 2114:       "sin", sin,
 2115:       "cos", cos,
 2116:       "atan", atan,
 2117:       "ln", log,
 2118:       "exp", exp,
 2119:       "sqrt", sqrt,
 2120:       0, 0
 2121:     @};
 2122: 
 2123: /* 記号表:`struct symrec'のリスト       */
 2124: symrec *sym_table = (symrec *)0;
 2125: @end group
 2126: 
 2127: @group
 2128: init_table ()  /* 数学関数を表に登録する */
 2129: @{
 2130:   int i;
 2131:   symrec *ptr;
 2132:   for (i = 0; arith_fncts[i].fname != 0; i++)
 2133:     @{
 2134:       ptr = putsym (arith_fncts[i].fname, FNCT);
 2135:       ptr->value.fnctptr = arith_fncts[i].fnct;
 2136:     @}
 2137: @}
 2138: @end group
 2139: @end smallexample
 2140: 
 2141: 単純に初期化リストを編集して、必要なインクルードファイルを追加するだけで、
 2142: 電卓に関数を追加できます。
 2143: 
 2144: 記号表に記号を登録して検索するために、2個の重要な関数があります。
 2145: 関数@code{putsym}は、登録すべきオブジェクトの
 2146: 名前と型(@code{VAR}や@code{FNCT})を渡されます。
 2147: オブジェクトはリストの先頭にリンクされ、
 2148: オブジェクトへのポインタが返されます。
 2149: 関数@code{getsym}は、検索すべき記号の名前を渡されます。
 2150: もし見つかれば記号へのポインタが返され、
 2151: 見つからなければ0が返されます。
 2152: 
 2153: @smallexample
 2154: symrec *
 2155: putsym (sym_name,sym_type)
 2156:      char *sym_name;
 2157:      int sym_type;
 2158: @{
 2159:   symrec *ptr;
 2160:   ptr = (symrec *) malloc (sizeof (symrec));
 2161:   ptr->name = (char *) malloc (strlen (sym_name) + 1);
 2162:   strcpy (ptr->name,sym_name);
 2163:   ptr->type = sym_type;
 2164:   ptr->value.var = 0; /* 関数の場合にも値を0にする */
 2165:   ptr->next = (struct symrec *)sym_table;
 2166:   sym_table = ptr;
 2167:   return ptr;
 2168: @}
 2169: 
 2170: symrec *
 2171: getsym (sym_name)
 2172:      char *sym_name;
 2173: @{
 2174:   symrec *ptr;
 2175:   for (ptr = sym_table; ptr != (symrec *) 0;
 2176:        ptr = (symrec *)ptr->next)
 2177:     if (strcmp (ptr->name,sym_name) == 0)
 2178:       return ptr;
 2179:   return 0;
 2180: @}
 2181: @end smallexample
 2182: 
 2183: 今度の関数@code{yylex}は、変数、数値、1文字の算術演算子を
 2184: 認識する必要があります。
 2185: 英字で始まり英数字からなる文字列は、記号表にどう書かれているかに応じて、
 2186: 変数と関数のどちらとも認識されます。
 2187: 
 2188: 文字列は、記号表を検索するために@code{getsym}に渡されます。
 2189: もし名前が表にあれば、その場所へのポインタと
 2190: 名前の型(@code{VAR}または@code{FNCT})が、
 2191: @code{yyparse}に返されます。
 2192: 名前がまだ表になければ、@code{putsym}を使って、
 2193: @code{VAR}として登録されます。
 2194: そして、ポインタと型(この場合には必ず@code{VAR})が
 2195: @code{yyparse}に返されます。
 2196: 
 2197: @code{yylex}の中で、数値と算術演算子の扱いに関する部分は、
 2198: 変更する必要がありません。
 2199: 
 2200: @smallexample
 2201: @group
 2202: #include <ctype.h>
 2203: yylex ()
 2204: @{
 2205:   int c;
 2206: 
 2207:   /* 空白を読み飛ばし、空白以外を得る         */
 2208:   while ((c = getchar ()) == ' ' || c == '\t');
 2209: 
 2210:   if (c == EOF)
 2211:     return 0;
 2212: @end group
 2213: 
 2214: @group
 2215:   /* 数値を読む   */
 2216:   if (c == '.' || isdigit (c))
 2217:     @{
 2218:       ungetc (c, stdin);
 2219:       scanf ("%lf", &yylval.val);
 2220:       return NUM;
 2221:     @}
 2222: @end group
 2223: 
 2224: @group
 2225:   /* 識別子を読む */
 2226:   if (isalpha (c))
 2227:     @{
 2228:       symrec *s;
 2229:       static char *symbuf = 0;
 2230:       static int length = 0;
 2231:       int i;
 2232: @end group
 2233: 
 2234: @group
 2235:       /* バッファの長さの初期値は40文字       */
 2236:       if (length == 0)
 2237:         length = 40, symbuf = (char *)malloc (length + 1);
 2238: 
 2239:       i = 0;
 2240:       do
 2241: @end group
 2242: @group
 2243:         @{
 2244:           /* あふれたのでバッファを大きくする */
 2245:           if (i == length)
 2246:             @{
 2247:               length *= 2;
 2248:               symbuf = (char *)realloc (symbuf, length + 1);
 2249:             @}
 2250:           /* 文字をバッファに変える           */
 2251:           symbuf[i++] = c;
 2252:           /* 次の文字を読む                   */
 2253:           c = getchar ();
 2254:         @}
 2255: @end group
 2256: @group
 2257:       while (c != EOF && isalnum (c));
 2258: 
 2259:       ungetc (c, stdin);
 2260:       symbuf[i] = '\0';
 2261: @end group
 2262: 
 2263: @group
 2264:       s = getsym (symbuf);
 2265:       if (s == 0)
 2266:         s = putsym (symbuf, VAR);
 2267:       yylval.tptr = s;
 2268:       return s->type;
 2269:     @}
 2270: 
 2271:   /* その他の文字は文字リテラルトークン       */
 2272:   return c;
 2273: @}
 2274: @end group
 2275: @end smallexample
 2276: 
 2277: このプログラムは、強力かつ柔軟です。
 2278: 新しい関数の追加は簡単です。
 2279: @code{pi}や@code{e}のようにあらかじめ定義された変数を追加するために
 2280: プログラムを変更することは、簡単な仕事でしょう。
 2281: 
 2282: 
 2283: @node Exercises,  , Multi-function Calc, Examples
 2284: @section 練習問題
 2285: @cindex exercises
 2286: @cindex 練習問題
 2287: 
 2288: @enumerate
 2289: @item
 2290: @file{math.h}にある関数のいくつかを、初期化リストに追加しなさい。
 2291: 
 2292: @item
 2293: 定数の名前と値を記憶する別の配列を追加しなさい。
 2294: そして、@code{init_table}を変更し、定数を記号表に追加しなさい。
 2295: 定数に型@code{VAR}を与えれば簡単でしょう。
 2296: 
 2297: @item
 2298: 初期化されていない変数について、値を書き込むのではなく、
 2299: 値を使おうとするとエラーを報告するように、プログラムを改良しなさい。
 2300: @end enumerate
 2301: 
 2302: 
 2303: @node Grammar File, Interface, Examples, Top
 2304: @chapter Bison文法ファイル
 2305: 
 2306: Bisonは、文脈自由文法の仕様を入力として受け取り、
 2307: その文法の正しいインスタンスを認識する、
 2308: C言語の関数を生成します。
 2309: 
 2310: Bison文法ファイルの名前は、通常@samp{.y}で終わります。
 2311: 
 2312: @menu
 2313: * Grammar Outline::   文法ファイルの概略.
 2314: * Symbols::           終端記号と非終端記号.
 2315: * Rules::             文法規則の書き方.
 2316: * Recursion::         再帰的規則の書き方.
 2317: * Semantics::         意味値とアクション.
 2318: * Declarations::      全ての種類のBison宣言の説明.
 2319: * Multiple Parsers::  一つのプログラムに一つより多くのBison構文解析器を
 2320:                         入れる.
 2321: @end menu
 2322: 
 2323: 
 2324: @node Grammar Outline, Symbols,  , Grammar File
 2325: @section Bison文法の概要
 2326: 
 2327: 
 2328: Bison文法ファイルは4つの主要な部分からなります。
 2329: それらを、適切な区切り文字とともに示します。
 2330: 
 2331: @example
 2332: %@{
 2333: @var{C宣言部(C declarations)}
 2334: %@}
 2335: 
 2336: @var{Bison宣言部(Bison declarations)}
 2337: 
 2338: %%
 2339: @var{文法規則部(Grammar rules)}
 2340: %%
 2341: 
 2342: @var{追加のCプログラム部(Additional C code)}
 2343: @end example
 2344: 
 2345: 
 2346: @samp{/* @dots{} */}で囲まれたコメントは、どの部分にも書けます。
 2347: 
 2348: @menu
 2349: * C Declarations::    C宣言部の構文と使用法.
 2350: * Bison Declarations::  Bison宣言部の構文と使用法.
 2351: * Grammar Rules::     文法規則部の構文と使用法.
 2352: * C Code::            追加のCコード部の構文と使用法.
 2353: @end menu
 2354: 
 2355: 
 2356: @node C Declarations, Bison Declarations,  , Grammar Outline
 2357: @subsection C宣言部
 2358: @cindex C declarations section
 2359: @cindex declarations, C
 2360: @cindex C宣言部
 2361: @cindex 宣言, C
 2362: 
 2363: 
 2364: @dfn{C宣言部(C declarations)}には、マクロ定義と、文法定義のアクションで
 2365: 使うための関数と変数の宣言があります。
 2366: これらは、@code{yyparse}の定義に優先するように、構文解析器ファイルの最初に
 2367: 複写されます。
 2368: ヘッダファイルから宣言を得るには@samp{#include}を使います。
 2369: C宣言がまったく必要ない場合は、この部分を囲む
 2370: @samp{%@{}と@samp{%@}}を省略できます。
 2371: 
 2372: 
 2373: @node Bison Declarations, Grammar Rules, C Declarations, Grammar Outline
 2374: @subsection Bison宣言部
 2375: @cindex Bison declarations (introduction)
 2376: @cindex declarations, Bison (introduction)
 2377: @cindex Bison宣言(導入)
 2378: @cindex 宣言, Bison(導入)
 2379: 
 2380: @dfn{Bison宣言部(Bison declarations)}は、終端記号と非終端記号の宣言、
 2381: 演算子の優先順位の指定などを含みます。
 2382: 単純な例では、宣言を省略できます。
 2383: @xref{Declarations, ,Bison Declarations}。
 2384: 
 2385: 
 2386: @node Grammar Rules, C Code, Bison Declarations, Grammar Outline
 2387: @subsection 文法規則部
 2388: @cindex grammar rules section
 2389: @cindex rules section for grammar
 2390: @cindex 文法規則部
 2391: @cindex 規則部,文法に対する
 2392: 
 2393: @dfn{文法規則部(grammar rules)}は、1つ以上のBison文法規則を含み、
 2394: それ以外は含みません。
 2395: @xref{Rules, ,Syntax of Grammar Rules}。
 2396: 
 2397: 少なくとも1つの文法規則が存在する必要があります。
 2398: また、文法規則より先に@samp{%%}が必要で、
 2399: もしそれ以前に何も記述されていなくても、省略できません。
 2400: 
 2401: 
 2402: @node C Code,  , Grammar Rules, Grammar Outline
 2403: @subsection 追加のCプログラム部
 2404: @cindex additional C code section
 2405: @cindex C code, section for additional
 2406: @cindex 追加のCプログラム部
 2407: @cindex Cプログラム, 追加の
 2408: 
 2409: @dfn{追加のCプログラム部(additional C code)}は、@dfn{C宣言部}が構文解析器ファイルの先頭に複写
 2410: されるのと同じように、構文解析器ファイルの末尾にそのまま複写されます。
 2411: 構文解析器ファイル中に置く必要があって、
 2412: @code{yyparse}の定義よりも前に置く必要のないものを、ここに置くと便利です。
 2413: たとえば、@code{yylex}と@code{yyerror}の定義は、
 2414: よくここに置かれます。
 2415: @xref{Interface, ,Parser C-Language Interface}。
 2416: 
 2417: もし直前の部が空ならば、文法規則と区別するための
 2418: @samp{%%}を省略できます。
 2419: 
 2420: Bison構文解析器は、名前が@samp{yy}で始まる多くの静的変数と、
 2421: 名前が@samp{YY}で始まる多くのマクロを含んでいます。
 2422: 本書で解説しているものを意図的に使う場合を除いて、
 2423: そのような名前を文法ファイルの追加のCプログラム部で使うのは避けるべきです。
 2424: 
 2425: 
 2426: @node Symbols, Rules, Grammar Outline, Grammar File
 2427: @section 記号、終端と非終端
 2428: @cindex nonterminal symbol
 2429: @cindex terminal symbol
 2430: @cindex token type
 2431: @cindex symbol
 2432: @cindex 非終端記号
 2433: @cindex 終端記号
 2434: @cindex トークン型
 2435: @cindex 記号
 2436: 
 2437: Bison文法の@dfn{記号(symbols)}は、
 2438: 言語の文法的分類を表現します。
 2439: 
 2440: @dfn{終端記号(terminal symbol)}
 2441: (@dfn{トークン型(tokens types)}ともいいます)は、
 2442: 構文的に等価なトークンのクラスを表します。
 2443: そのクラスのトークンが許されることを表すために、
 2444: 文法規則の中で記号を使えます。
 2445: その記号は、Bison構文解析器の中で番号で表現され、
 2446: @code{yylex}関数は、どのような種類のトークンが読み込まれたかを示すために、
 2447: トークン番号を返します。
 2448: これを表す記号を知っていればよく、その番号を知っている必要はありません。
 2449: 
 2450: @dfn{非終端記号(nonterminal symbol)}は、
 2451: 構文的に等価なグループを表現します。
 2452: 記号名は文法規則の記述に使われます。
 2453: 通常、非終端記号名を小文字で書きます。
 2454: 
 2455: 記号名は、英字、先頭以外での数字、下線記号(@samp{_})とピリオドからなります。
 2456: ピリオド記号(@samp{.})は、非終端記号の名前には使えますが、
 2457: 終端記号の名前には使えません。
 2458: 
 2459: 文法中で終端記号を記述するには3種類の方法があります。
 2460: 
 2461: @itemize @bullet
 2462: @item
 2463: @dfn{名前付きトークン型(named token type)}を、
 2464: C言語における識別子と同様な、識別子とともに書きます。
 2465: 通常、大文字で書きます。
 2466: これらは@code{%token}のようなBison宣言とともに定義する必要があります。
 2467: @xref{Token Decl, ,Token Type Names}。
 2468: 
 2469: @item
 2470: @cindex character token
 2471: @cindex literal token
 2472: @cindex single-character literal
 2473: @cindex 文字トークン
 2474: @cindex リテラルトークン
 2475: @cindex 1文字リテラル
 2476: @dfn{文字トークン型(character token type)}、
 2477: すなわち@dfn{リテラル文字トークン(literal character token)}は、
 2478: C言語の文字定数と同じ構文で書かれ、
 2479: たとえば@code{'+'}は文字トークン型です。
 2480: 意味値データ型(@pxref{Value Type, ,Data Types of Semantic Values})、
 2481: 結合性、優先順位(@pxref{Precedence, ,Operator Precedence})を
 2482: 指定する必要がなければ、
 2483: 文字トークン型を宣言する必要はありません。
 2484: 
 2485: 通常、文字トークン型は、特別な文字@footnote{【訳注】英数字以外の文字。}から
 2486: なるトークンを表すためだけに使います。
 2487: たとえば、トークン型@code{'+'}を、
 2488: トークンとしての@samp{+}文字を表すために使います。
 2489: このようにする義務はありませんが、そうしないと、
 2490: あなたが書いたプログラムを読む人が混乱するでしょう。
 2491: 
 2492: C言語の文字リテラルで使われる通常のエスケープシーケンス
 2493: @footnote{【訳注】@samp{\}に続く表現。}を、Bisonでも使えます。
 2494: しかし、@code{'\0'}だけはASCII符号の0を表し、
 2495: @code{yylex}がファイルの終わりを示す符号なので、
 2496: 文字リテラルとしては使えません
 2497: (@pxref{Calling Convention, ,Calling Convention for @code{yylex}})。
 2498: 
 2499: @item
 2500: @cindex string token
 2501: @cindex literal string token
 2502: @cindex multi-character literal
 2503: @cindex 文字列トークン
 2504: @cindex リテラル文字列トークン
 2505: @cindex 複数文字リテラル
 2506: @dfn{リテラル文字列トークン(literal string token)}は、
 2507: C言語における文字列定数と同様に書きます。
 2508: たとえば、@code{"<="}がリテラル文字列トークンです。
 2509: 意味値(@pxref{Value Type})、
 2510: 結合性、優先順位(@pxref{Precedence, ,Operator Precedence})を
 2511: 指定する必要がなければ、
 2512: リテラル文字列トークンを宣言する必要はありません。
 2513: 
 2514: @code{%token}宣言(@pxref{Token Decl, ,Token Declarations})を使って、
 2515: リテラル文字列トークンを、記号名の別名として関連づけられます。
 2516: そうしないと、字句解析器は、
 2517: @code{yytname}表(@pxref{Calling Convention})を使って、
 2518: リテラル文字列トークンからトークン番号を検索する必要があります。
 2519: 
 2520: @strong{【警告】}@code{yacc}ではリテラル文字列トークンを使えません。
 2521: 
 2522: 通常、特殊文字の列からなるトークンの表現にのみ、
 2523: リテラル文字列トークンを使います。
 2524: たとえば、トークンとしての@samp{<=}を表すために、
 2525: トークン型@code{"<="}を使うべきです。
 2526: そうする義務はありませんが、そうしないと、
 2527: あなたが書いたプログラムを読む人が混乱するでしょう。
 2528: 
 2529: C言語で使えるエスケープシーケンスはすべてBisonでも使えます。
 2530: リテラル文字列トークンは、2文字以上からなります。
 2531: もし、トークンが1文字ならば、前述の1文字トークンを使ってください。
 2532: @end itemize
 2533: 
 2534: 終端記号を書く方法は、終端記号の文法的意味に関係なく、
 2535: 規則の中に現れる位置と、
 2536: 構文解析器関数が記号を返す方法に関係します。
 2537: 
 2538: @code{yylex}が返す値は、終端記号のどれかを表し、
 2539: 入力の終わりでは0です。
 2540: 文法規則の中でどの方法でトークン型を書いても、
 2541: @code{yylex}を定義する書き方は同じです。
 2542: 1文字トークン型に対する符号は、その文字のASCII符号なので、
 2543: @code{yylex}は必要な符号を生成するために同一の文字定数を使えます。
 2544: 名前を付けられたトークン型はそれぞれ、
 2545: 構文解析器ファイルの中でCのマクロになるので、
 2546: @code{yylex}は符号に対するマクロ名を使えます。
 2547: これが、終端記号の名前にピリオド記号を使えない理由です。
 2548: @xref{Calling Convention, ,Calling Convention for @code{yylex}}。
 2549: 
 2550: @code{yylex}が構文解析器と別のソースファイルの中に書かれる場合には、
 2551: そこでトークン型マクロ定義を使えるように準備する必要があります。
 2552: @samp{-d}オプションを付けてBisonを実行してください。
 2553: すると、マクロ定義が@file{@var{name}.tab.h}というファイルに書かれ、
 2554: 必要に応じて別のソースファイルからインクルードできます。
 2555: @xref{Invocation, ,Invoking Bison}。
 2556: 
 2557: 記号@code{error}は、エラー回復用に予約された終端記号(@pxref{Error Recovery})
 2558: で、他の目的に使うべきではありません。
 2559: 実際に、@code{yylex}がこの値を返すことは決してありません。
 2560: 
 2561: 
 2562: @node Rules, Recursion, Symbols, Grammar File
 2563: @section 文法規則の構文
 2564: @cindex rule syntax
 2565: @cindex grammar rule syntax
 2566: @cindex syntax of grammar rules
 2567: @cindex 規則の構文
 2568: @cindex 文法規則の構文
 2569: @cindex 構文, 文法規則
 2570: 
 2571: Bison文法規則は、一般的に次の書式です。
 2572: 
 2573: @example
 2574: @group
 2575: @var{result}: @var{components}@dots{}
 2576:         ;
 2577: @end group
 2578: @end example
 2579: 
 2580: @var{result}は、この規則が記述する非終端記号で、
 2581: @var{components}は、この規則で一緒に置かれるさまざまな
 2582: 終端および非終端記号です。
 2583: 例を示します。
 2584: 
 2585: @example
 2586: @group
 2587: exp:      exp '+' exp
 2588:         ;
 2589: @end group
 2590: @end example
 2591: 
 2592: この例では、@samp{+}トークンを間にはさんで
 2593: 型@code{exp}の2つのグループ化が行われ、
 2594: 型@code{exp}のより大きなグループができます。
 2595: 
 2596: 規則の中の空白@footnote{【訳注】任意の数の空白文字、タブ符号、改行符号。}は、
 2597: 記号を分けるだけの意味を持ちます。
 2598: 必要に応じて、余分な空白を書いてもかまいません。
 2599: 
 2600: @var{components}の周辺にあるものは、
 2601: 規則の意味を決定する@var{アクション(action)}になることができます。
 2602: アクションは、次のようになります。
 2603: 
 2604: @example
 2605: @{@var{C statements}@}
 2606: @end example
 2607: 
 2608: 通常、1つだけのアクションと、それに続く@var{components}があります。
 2609: @xref{Actions}。
 2610: 
 2611: @findex |
 2612: 同一の@var{result}に対する複数の規則は、
 2613: 別々に書くこともできますし、
 2614: 次の例のように縦線記号@samp{|}で区切ってまとめて書くことも可能です。
 2615: 
 2616: @ifinfo
 2617: @example
 2618: @var{result}:   @var{rule1-components}@dots{}
 2619:         | @var{rule2-components}@dots{}
 2620:         @dots{}
 2621:         ;
 2622: @end example
 2623: @end ifinfo
 2624: @iftex
 2625: @example
 2626: @group
 2627: @var{result}:    @var{rule1-components}@dots{}
 2628:         | @var{rule2-components}@dots{}
 2629:         @dots{}
 2630:         ;
 2631: @end group
 2632: @end example
 2633: @end iftex
 2634: 
 2635: まとめて書いても、それぞれの規則は別々のものとみなされます。
 2636: 
 2637: もし、規則中の@var{components}が空ならば、
 2638: @var{result}が空の列にマッチできることを意味します。
 2639: 例として、カンマで区切られた0個以上の@code{exp}のグループを
 2640: 定義する方法を示します。
 2641: 
 2642: @example
 2643: @group
 2644: expseq:   /* 空 */
 2645:         | expseq1
 2646:         ;
 2647: @end group
 2648: 
 2649: @group
 2650: expseq1:  exp
 2651:         | expseq1 ',' exp
 2652:         ;
 2653: @end group
 2654: @end example
 2655: 
 2656: 空の@var{component}を持つ規則には、通常
 2657: @samp{/* 空 */}という注釈を書きます。
 2658: 
 2659: 
 2660: @node Recursion, Semantics, Rules, Grammar File
 2661: @section 再帰的規則
 2662: @cindex recursive rule
 2663: @cindex 再帰的規則
 2664: 
 2665: @var{result}である非終端記号が規則の右側にも現れる場合に、
 2666: その規則は@dfn{再帰的(recursive)}であるといいます。
 2667: Bison文法の大部分は再帰的規則を使います。
 2668: なぜならば、任意の数の並びを定義する唯一の方法が、
 2669: 再帰的規則だからです。
 2670: 1つ以上のカンマで区切られた式の並びの定義を考えてみましょう。
 2671: 
 2672: @example
 2673: @group
 2674: expseq1:  exp
 2675:         | expseq1 ',' exp
 2676:         ;
 2677: @end group
 2678: @end example
 2679: 
 2680: @cindex left recursion
 2681: @cindex right recursion
 2682: @cindex 左再帰
 2683: @cindex 右再帰
 2684: 
 2685: @code{expseq1}で使われている再帰は、規則の右側の中でもっとも左側にあるので、
 2686: このような再帰を@dfn{左再帰(left recursion)}と呼びます。
 2687: 逆に、同じ構造を@dfn{右再帰(right recursion)}を使って書いてみます。
 2688: 
 2689: @example
 2690: @group
 2691: expseq1:  exp
 2692:         | exp ',' expseq1
 2693:         ;
 2694: @end group
 2695: @end example
 2696: 
 2697: あらゆる並びを、左再帰を使っても、右再帰を使っても、定義できます。
 2698: しかし、限られたスタック容量で任意の数の並びを走査できるので、
 2699: つねに左再帰を使うべきです。
 2700: 右再帰では、規則が適用される前にすべての要素をスタックに積む必要があるので、
 2701: 要素の数に比例するスタック領域を消費します。
 2702: 詳細については、@xref{Algorithm, ,The Bison Parser Algorithm }。
 2703: 
 2704: @cindex mutual recursion
 2705: @cindex 相互再帰
 2706: 
 2707: 規則の結果が直接その右側には含まれず、
 2708: 右側にある非終端記号の中に含まれるとき、
 2709: @dfn{間接(indirect)}すなわち@dfn{相互(mutual)}再帰が起きます。
 2710: 
 2711: 例を示します。
 2712: 
 2713: @example
 2714: @group
 2715: expr:     primary
 2716:         | primary '+' primary
 2717:         ;
 2718: @end group
 2719: 
 2720: @group
 2721: primary:  constant
 2722:         | '(' expr ')'
 2723:         ;
 2724: @end group
 2725: @end example
 2726: 
 2727: この例では、それぞれの規則が互いに参照しているので、
 2728: 2個の相互再帰が定義されています。
 2729: 
 2730: 
 2731: @node Semantics, Declarations, Recursion, Grammar File
 2732: @section 言語の意味の定義
 2733: @cindex defining language semantics
 2734: @cindex language semantics, defining 
 2735: @cindex 言語の意味の定義
 2736: @cindex 定義, 言語の意味
 2737: 
 2738: 言語に対する文法規則は、文法だけを決めます。
 2739: 意味は、各種のトークンとグループ化に対応する意味値により、
 2740: 各種のグループ化が認識されるときに、決定されます。
 2741: 
 2742: 電卓の例では、式のそれぞれに対応する値が適切な数値なので、
 2743: 電卓は正確に計算できます。
 2744: グループ@w{@samp{@var{x} + @var{y}}}に
 2745: 対応するアクションが、@var{x}と@var{y}に関する数値の和を計算します。
 2746: 
 2747: @menu
 2748: * Value Type::        全ての意味値に一つのデータ型を指定する.
 2749: * Multiple Types::    複数の別のデータ型を指定する.
 2750: * Actions::           アクションは文法規則の意味的定義.
 2751: * Action Types::      アクションが操作するデータ型を指定する.
 2752: * Mid-Rule Actions::  ほとんどのアクションは規則の最後に行く.
 2753:                       これは規則の最中で、いつ、なぜ、どのように
 2754:                         例外アクションを使用するかを指示する.
 2755: @end menu
 2756: 
 2757: 
 2758: @node Value Type, Multiple Types,  , Semantics
 2759: @subsection データ型と意味値
 2760: @cindex semantic value type
 2761: @cindex value type, semantic
 2762: @cindex data types of semantic values
 2763: @cindex default data type
 2764: @cindex 意味値型
 2765: @cindex 値型, 意味
 2766: @cindex 意味値のデータ型
 2767: @cindex 省略時データ型
 2768: 
 2769: 単純なプログラムでは、言語の要素のすべての意味値に対して同じデータ型を
 2770: 使えば十分です。
 2771: 逆ポーランド記法と中間記法電卓の例では、そうでした
 2772: (@pxref{RPN Calc, ,Reverse Polish Notation Calculator})。
 2773: 
 2774: 特に指定しないと、Bisonはすべての意味値に対して@code{int}型を使います。
 2775: 他の型を使うには、次の例のように、マクロ@code{YYSTYPE}を定義します。
 2776: 
 2777: @example
 2778: #define YYSTYPE double
 2779: @end example
 2780: 
 2781: このマクロ定義は、文法ファイルのC宣言部に置く必要があります
 2782: (@pxref{Grammar Outline, ,Outline of a Bison Grammar})。
 2783: 
 2784: 
 2785: @node Multiple Types, Actions, Value Type, Semantics
 2786: @subsection 複数の値型
 2787: 
 2788: 多くのプログラムでは、異なる種類のトークンとグループに対して、
 2789: 異なるデータ型が必要です。
 2790: たとえば、数値定数は@code{int}型や@code{long}型を必要とし、
 2791: 文字列定数は@code{char *}型を必要とし、
 2792: 識別子は記号表の項目へのポインタを必要とするでしょう。
 2793: 
 2794: 同一の構文解析器内で、意味値に対して2つ以上のデータ型を使うには、
 2795: 次の2項目が必要です。
 2796: 
 2797: @itemize @bullet
 2798: @item
 2799: Bison宣言の@code{%union}で、考えられるデータ型全体の集合を指定します
 2800: (@pxref{Union Decl, ,The Collection of Value Types})。
 2801: 
 2802: @item
 2803: 終端または非終端記号のそれぞれについて、
 2804: その意味値を使うために、上記の型のどれか1つを選びます。
 2805: トークンに対する型の指定には、Bison宣言の@code{%token}を使います
 2806: (@pxref{Token Decl, ,Token Type Names})。
 2807: グループ化に対する型の指定には、Bison宣言の@code{%type}を使います
 2808: (@pxref{Type Decl, ,Nonterminal Symbols})。
 2809: @end itemize
 2810: 
 2811: 
 2812: @node Actions, Action Types, Multiple Types, Semantics
 2813: @subsection アクション
 2814: @cindex action
 2815: @cindex アクション
 2816: @vindex $$
 2817: @vindex $@var{n}
 2818: 
 2819: 文法規則にともなうアクションは、その規則が認識されるたびに実行される
 2820: Cのプログラムからなります。
 2821: アクションの仕事のほとんどは、関連するトークンまたは小さいグループから
 2822: 規則にしたがって構成されるグループの、意味値の計算です。
 2823: 
 2824: アクションは、Cの複文のように、ブレースで囲まれたCの文からなります。
 2825: アクションは、規則のどの場所にも置け、その場所で実行されます。
 2826: 規則のほとんどは、規則の終わりの構成要素の並びの後に、
 2827: 1つだけアクションを持ちます。
 2828: 規則の途中に置かれたアクションは、手の込んだ方法で特別な目的に使われます
 2829: (@pxref{Mid-Rule Actions, ,Actions in Mid-Rule})。
 2830: 
 2831: アクションの中のCで書かれたプログラムは、
 2832: 規則の第@var{n}番目の要素に対応する意味値を、
 2833: @code{$@var{n}}という書式で参照できます。
 2834: また、その規則が構成するグループの意味値を、
 2835: @code{$$}という書式で参照できます。
 2836: アクションが構文解析器ファイルに複写されるときに、Bisonは、
 2837: 上記の構成要素を配列要素への参照に変換します。
 2838: 
 2839: 例を示します。
 2840: 
 2841: @example
 2842: @group
 2843: exp:    @dots{}
 2844:         | exp '+' exp
 2845:             @{ $$ = $1 + $3; @}
 2846: @end group
 2847: @end example
 2848: 
 2849: この規則は、加算記号で結び付けられた2つの小さい@code{exp}グループから、
 2850: 1つの@code{exp}を構成します。
 2851: このアクションの中で、@code{$1}と@code{$3}は、
 2852: 規則の右側の最初と3番目の記号である@code{exp}グループの
 2853: 意味値を参照します。
 2854: この規則によって認識される加算式の値になるように、
 2855: 和が@code{$$}に代入されます。
 2856: もし、@samp{+}トークンに有用な値があるならば、
 2857: それを@code{$2}として参照できるでしょう。
 2858: 
 2859: @cindex default action
 2860: @cindex 省略時アクション
 2861: 
 2862: 規則に対してアクションを指定しなければ、Bisonは、
 2863: 省略時アクション@w{@code{$$ = $1}}を補います。
 2864: したがって、規則の最初の記号の値が規則全体の値になります。
 2865: もちろん、両者の型が一致する場合にのみ、省略時アクションは有効です。
 2866: 空規則に対する省略時アクションは無意味です。
 2867: すべての空規則は、その規則の値が必要ならば、
 2868: 明示的なアクションを持つ必要があります。
 2869: 
 2870: @code{$@var{n}}の@var{n}は0または負が許され、
 2871: 現在の規則にマッチする@emph{前に}スタックに積まれていた
 2872: トークンとグループの意味値を参照します。
 2873: これは非常に危険な手法で、安全に使うためには、
 2874: その規則が適用される文脈をあなたが完全に理解している必要があります。
 2875: これを安全に使える例を示します。
 2876: 
 2877: @example
 2878: @group
 2879: foo:      expr bar '+' expr  @{ @dots{} @}
 2880:         | expr bar '-' expr  @{ @dots{} @}
 2881:         ;
 2882: @end group
 2883: 
 2884: @group
 2885: bar:      /* 空 */
 2886:         @{ previous_expr = $0; @}
 2887:         ;
 2888: @end group
 2889: @end example
 2890: 
 2891: @code{bar}がここに書かれた方法でのみ使われるならば、
 2892: @code{foo}の定義の中で@code{bar}より前の
 2893: @code{expr}の値を@code{$0}が参照します。
 2894: 
 2895: 
 2896: @node Action Types, Mid-Rule Actions, Actions, Semantics
 2897: @subsection アクション中の値のデータ型
 2898: @cindex action data types
 2899: @cindex data types in actions
 2900: @cindex アクションのデータ型
 2901: @cindex データ型, アクション
 2902: 
 2903: すべての意味値に対して同一のデータ型を使っているのならば、
 2904: @code{$$}と@code{$@var{n}}はそのデータ型を持ちます。
 2905: 
 2906: さまざまなデータ型を指定するために@code{%union}を使っているならば、
 2907: 意味値を持つ終端記号と非終端記号のそれぞれに対して、
 2908: データ型の中から適切なものを選ぶように宣言する必要があります。
 2909: すると、@code{$$}と@code{@var{n}}を使うたびに、
 2910: 規則の中でそれらがどの記号を参照するかに応じて、
 2911: データ型が決められます。
 2912: 例を示します。
 2913: 
 2914: @example
 2915: @group
 2916: exp:    @dots{}
 2917:         | exp '+' exp
 2918:             @{ $$ = $1 + $3; @}
 2919: @end group
 2920: @end example
 2921: 
 2922: @code{$1}と@code{$3}は@code{exp}という種類の記号を参照するので、
 2923: @code{$1}と@code{$3}は、非終端記号@code{exp}に対して宣言された
 2924: データ型を持ちます。
 2925: もし、@code{$2}が使われるならば、どのような型であれ、
 2926: 終端記号@code{+}に対して宣言されたデータ型が使われます。
 2927: 
 2928: 別の方法として、値を参照するときにそのデータ型を指定できます。
 2929: そのためには、参照のための@samp{$}記号の後に@samp{<@var{type}>}を
 2930: 挿入します。例を示します。
 2931: 
 2932: @example
 2933: @group
 2934: %union @{
 2935:   int itype;
 2936:   double dtype;
 2937: @}
 2938: @end group
 2939: @end example
 2940: 
 2941: この場合に、@code{$<itype>1}と書けば、
 2942: 最初の要素を@code{int}型として参照でき、@code{$<dtype>1}と書けば、
 2943: @code{double}型として参照できます。
 2944: 
 2945: 
 2946: @node Mid-Rule Actions,  , Action Types, Semantics
 2947: @subsection 規則の途中のアクション
 2948: @cindex actions in mid-rule
 2949: @cindex mid-rule actions
 2950: @cindex 規則の途中のアクション
 2951: @cindex アクション, 規則の途中
 2952: 
 2953: まれに、アクションを規則の途中に置くと便利な場合があります。
 2954: これらのアクションは、通常の規則の終わりに置かれたアクションと同様に
 2955: 記述されますが、構文解析器が後に続く要素を認識する前に実行されます。
 2956: 
 2957: 規則の途中のアクションは、そのアクションよりも前にある要素を
 2958: @code{$@var{n}}を使って参照できますが、後に続く要素は
 2959: まだ構文解析されていないので参照できません。
 2960: 
 2961: 規則の途中のアクション自身は、規則の要素の1つとして数えられます。
 2962: 同じ規則の中に別のアクションが続く場合(通常は最後)に問題が起きます。
 2963: @code{$@var{n}}に使う番号@var{n}に
 2964: 規則の途中のアクションを数えるのを忘れないように注意してください。
 2965: 
 2966: 規則の途中のアクションは、意味値を持てます。
 2967: そのアクションは、@code{$$}への代入で値を定め、
 2968: 後に続くアクションの中で、@code{$@var{n}}で値を参照できます。
 2969: アクションに記号名を対応させる方法がないので、
 2970: アクションのデータ型を宣言できません。
 2971: そこで、アクションの意味を参照するときに、
 2972: @samp{$<@dots{}>}を使ってデータ型を指定する必要があります。
 2973: 
 2974: 
 2975: 規則の途中のアクションでは、@code{$$}への代入が規則の値に関係しないので、
 2976: 規則全体の値を設定する方法はありません。
 2977: 規則全体の値を設定する唯一の方法は、
 2978: 規則の最後に置かれた通常のアクションです。
 2979: 
 2980: 架空のコンパイラの例を示します。
 2981: ここでは、@samp{let (@var{variable}) @var{statement}}のような書式の
 2982: @code{let}文を使え、@var{statement}の持続期間中に一時的に
 2983: @var{variable}という名前の変数を作ります。
 2984: これを構文解析するために、@var{statement}を解析している間、
 2985: @var{variable}を記号表に置いておき、
 2986: 後で記号表から削除する必要があります。
 2987: これを実現する方法を示します。
 2988: 
 2989: @example
 2990: @group
 2991: stmt:   LET '(' var ')'
 2992:                 @{ $<context>$ = push_context ();
 2993:                   declare_variable ($3); @}
 2994:         stmt    @{ $$ = $6;
 2995:                   pop_context ($<context>5); @}
 2996: @end group
 2997: @end example
 2998: 
 2999: @samp{let (@var{variable})}が認識されるとすぐに、
 3000: 最初のアクションが実行されます。
 3001: そのアクションは、現在の意味文脈、すなわち参照可能な変数の表の複製を、
 3002: データ型共用体の中の@code{context}型で、
 3003: アクションの意味値として保存します。
 3004: そして、@code{declare_variable}を呼び出して、
 3005: 新しい変数を記号表に追加します。
 3006: 最初のアクションが終わると、後続する@code{stmt}の解析が可能になります。
 3007: 規則の途中のアクションが5番目の要素であることに注意してください。
 3008: したがって、@samp{stmt}は6番目の要素になります。
 3009: 
 3010: 後続する文が解析されると、その意味値が@code{let}文全体の意味値になります。
 3011: そして、最初のアクションの意味値は、
 3012: 変数の表を元に戻すために使われます。
 3013: そこで、@code{let}文中での一時変数が表から削除され、
 3014: 構文解析されるプログラムの残りの部分では一時変数が存在しません。
 3015: 
 3016: 構文解析器は、アクションを実行する順序を決めるために、
 3017: 構文解析する必要があるので、
 3018: 規則が完全に認識される前にアクションを実行することは、
 3019: しばしば不整合を起こします。
 3020: たとえば、後述の2個の規則は、規則の途中のアクションを持たないので、
 3021: 実行可能な構文解析器の中で共存できます。
 3022: それは、構文解析器は開きブレーストークンをシフトでき、
 3023: 宣言があるかどうか調べるために後に続くものを先読みできるからです。
 3024: 
 3025: @example
 3026: @group
 3027: compound: '@{' declarations statements '@}'
 3028:         | '@{' statements '@}'
 3029:         ;
 3030: @end group
 3031: @end example
 3032: 
 3033: しかし、次の例のように、規則の途中のアクションを加えると、
 3034: この規則は働かなくなります。
 3035: 
 3036: @example
 3037: @group
 3038: compound: @{ prepare_for_local_variables (); @}
 3039:           '@{' declarations statements '@}'
 3040: @end group
 3041: @group
 3042:         | '@{' statements '@}'
 3043:         ;
 3044: @end group
 3045: @end example
 3046: 
 3047: ここでは、開きブレースを見つけた時点で、
 3048: 規則の途中のアクションを実行する必要があるかどうかの決定を迫られます。
 3049: 言い換えれば、正しく判断するための十分な情報なしに、
 3050: ある規則か別の規則のどちらかにゆだねる必要があります。
 3051: 開きブレーストークンは、これを読んだ時点では構文解析器が
 3052: 何をすべきか決定する途中なので、@dfn{先読み(look-ahead)}トークンと
 3053: 呼ばれます。@xref{Look-Ahead, ,Look-Ahead Tokens}。
 3054: 
 3055: 次のように同一のアクションを置くことで、
 3056: この問題を解決できるように思えるかもしれません。
 3057: 
 3058: @example
 3059: @group
 3060: compound: @{ prepare_for_local_variables (); @}
 3061:           '@{' declarations statements '@}'
 3062:         | @{ prepare_for_local_variables (); @}
 3063:           '@{' statements '@}'
 3064:         ;
 3065: @end group
 3066: @end example
 3067: 
 3068: しかし、Bisonには2つのアクションが同一であるかどうかわからないので、
 3069: 問題は解決しません。
 3070: Bisonは、アクションの中のCで書かれたプログラムを、
 3071: 決して解釈しようとしません。
 3072: 
 3073: C言語のように、最初のトークンによって文と宣言を区別できるような
 3074: 文法ならば、実現可能な解決方法の1つは、次の例のように、
 3075: 開きブレースの後にアクションを置くことです。
 3076: 
 3077: @example
 3078: @group
 3079: compound: '@{' @{ prepare_for_local_variables (); @}
 3080:           declarations statements '@}'
 3081:         | '@{' statements '@}'
 3082:         ;
 3083: @end group
 3084: @end example
 3085: 
 3086: これで、続く宣言または文の最初のトークンによって、
 3087: Bisonがどちらの規則を使うべきかわかります。
 3088: 
 3089: 別の解決方法は、サブルーチンとして働く非終端記号の内側に、
 3090: アクションを埋め込むことです。
 3091: 
 3092: @example
 3093: @group
 3094: subroutine: /* 空 */
 3095:           @{ prepare_for_local_variables (); @}
 3096:         ;
 3097: 
 3098: @end group
 3099: 
 3100: @group
 3101: compound: subroutine
 3102:           '@{' declarations statements '@}'
 3103:         | subroutine
 3104:           '@{' statements '@}'
 3105:         ;
 3106: @end group
 3107: @end example
 3108: 
 3109: これで、Bisonは@code{compound}に対してどちらの規則を使うべきか決めずに、
 3110: @code{subroutine}に対する規則中のアクションを実行できます。
 3111: 任意の規則中のアクションは、この方法によって、
 3112: 規則の最後のアクションに変換できます。
 3113: 実際に、Bisonの内部では、このようにして、
 3114: 規則中のアクションという機能が実現されています。
 3115: 
 3116: 
 3117: @node Declarations, Multiple Parsers, Semantics, Grammar File
 3118: @section Bison宣言
 3119: @cindex declarations, Bison
 3120: @cindex Bison declarations
 3121: @cindex 宣言, Bison
 3122: @cindex Bison宣言
 3123: 
 3124: Bison文法ファイルの@dfn{Bison宣言(Bison declarations)}部では、
 3125: 文法の定式化に使う記号を定義し、意味値のデータ型を定義します。
 3126: @xref{Symbols}。
 3127: 
 3128: @code{'+'}や@code{'*'}のような1文字リテラルトークンを除く
 3129: すべてのトークンの型名を宣言する必要があります。
 3130: 非終端記号については、その意味値に対してどのデータ型を使うか
 3131: 指定したければ、宣言する必要があります
 3132: (@pxref{Multiple Types, ,More Than One Value Type})。
 3133: 
 3134: 特に指定しないと、文法ファイル中の最初の規則は、
 3135: 開始記号を特定します。
 3136: 他の記号を開始記号にしたければ、明示的に宣言する必要があります
 3137: (@pxref{Language and Grammar, ,Languages and Context-Free Grammars})。
 3138: 
 3139: @menu
 3140: * Token Decl::        終端記号を宣言する.
 3141: * Precedence Decl::   優先順位と結合規則とともに終端を宣言する.
 3142: * Union Decl::        全ての意味値の型の集合を宣言する.
 3143: * Type Decl::         非終端記号のための型の選択を宣言する.
 3144: * Expect Decl::       シフト/還元衝突の警告を抑制する.
 3145: * Start Decl::        開始記号を指定する.
 3146: * Pure Decl::         再入構文解析器を要求する.
 3147: * Decl Summary::      全てのBison宣言の表.
 3148: @end menu
 3149: 
 3150: 
 3151: @node Token Decl, Precedence Decl,  , Declarations
 3152: @subsection トークン型名
 3153: @cindex declaring token type names
 3154: @cindex token type names, declaring
 3155: @cindex declaring literal string tokens
 3156: @findex %token
 3157: @cindex トークン型名の宣言
 3158: @cindex トークン型名, 宣言
 3159: @cindex リテラル文字列トークンの宣言
 3160: 
 3161: トークン型名、すなわち終端記号を、基本的には次のように宣言します。
 3162: 
 3163: @example
 3164: %token @var{name}
 3165: @end example
 3166: 
 3167: Bisonは、これを、構文解析器の中の@code{#define}ディレクティブに変換します。
 3168: したがって、関数@code{yylex}が構文解析器ファイルの中にあれば、
 3169: そこで名前@var{name}をこのトークン型を表すために使えます。
 3170: 
 3171: 優先順位を指定したければ、@code{%token}の代わりに、
 3172: @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。
 3173: @xref{Precedence Decl, ,Operator Precedence}。
 3174: 
 3175: トークンの名前の直後に整数値を書くことで、
 3176: そのトークン型に対応する数値符号を明示的に指定できます。
 3177: 
 3178: @example
 3179: %token NUM 300
 3180: @end example
 3181: 
 3182: しかし、Bisonにすべてのトークン型に対する数値符号の割り当てをまかせる
 3183: ことがいちばんです。Bisonは、トークン型どうしやASCII文字符号と
 3184: 衝突が起きないように、自動的に数値符号を割り当てます。
 3185: 
 3186: スタック型が共用体である場合には、
 3187: @code{%token}あるいは他のトークン宣言に、
 3188: 小なり記号と大なり記号で区切った型名を追加する必要があります
 3189: (@pxref{Multiple Types, ,More Than One Value Type})。
 3190: 
 3191: 例を示します。
 3192: 
 3193: @example
 3194: @group
 3195: %union @{              /* スタックのデータ型を定義する */
 3196:   double val;
 3197:   symrec *tptr;
 3198: @}
 3199: %token <val> NUM      /* トークン「NUM」とその型を定義する */
 3200: @end group
 3201: @end example
 3202: 
 3203: トークン型名を宣言する@code{%token}宣言の末尾に
 3204: リテラル文字列を書くことで、リテラル文字列トークンと
 3205: トークン型名を関連づけできます。
 3206: 
 3207: @example
 3208: %token arrow "=>"
 3209: @end example
 3210: 
 3211: C言語に対する文法では、次の例のように、
 3212: 等価なリテラル文字列トークンに名前を指定しています。
 3213: 
 3214: @example
 3215: %token  <operator>  OR      "||"
 3216: %token  <operator>  LE 134  "<="
 3217: %left  OR  "<="
 3218: @end example
 3219: 
 3220: リテラル文字列とトークン名を等価にすれば、それ以降の文法規則の
 3221: 宣言の中で、両者を同様に使えます。
 3222: @code{yylex}関数は、トークン型の数値符号を得るために、
 3223: トークン名とリテラル文字列の両方を使えます
 3224: (@pxref{Calling Convention})。
 3225: 
 3226: 
 3227: @node Precedence Decl, Union Decl, Token Decl, Declarations
 3228: @subsection 演算子の優先順位
 3229: @cindex precedence declarations
 3230: @cindex declaring operator precedence
 3231: @cindex operator precedence, declaring
 3232: @cindex 優先順位宣言
 3233: @cindex 宣言, 演算子の優先順位
 3234: @cindex 演算子の優先順位
 3235: 
 3236: トークンの宣言とトークンの優先順位および結合規則の指定をまとめて行いたいならば、
 3237: @code{%left}、@code{%right}、@code{%nonassoc}のどれかを使います。
 3238: これらは、@dfn{優先順位宣言(precedence declarations)}と呼ばれます。
 3239: 演算子の優先順位の詳細については、
 3240: @xref{Precedence, ,Operator Precedence}。
 3241: 
 3242: 優先順位宣言の構文は、@code{%token}を使う宣言の構文と同じです。
 3243: 
 3244: @example
 3245: %left @var{symbols}@dots{}
 3246: @end example
 3247: 
 3248: 次のようにも書けます。
 3249: 
 3250: @example
 3251: %left <@var{type}> @var{symbols}@dots{}
 3252: @end example
 3253: 
 3254: これらの宣言は、@code{%token}を使う宣言が目的とする
 3255: すべての機能を持っています。
 3256: それに加えて、次のように結合性と、すべての@var{symbols}についての優先順位を指定します。
 3257: 
 3258: @itemize @bullet
 3259: @item
 3260: 演算子@var{op}の結合性は、この演算子が繰り返し使われた場合の
 3261: 動作を指定します。つまり、@samp{@var{x} @var{op} @var{y} @var{op} @var{z}}が
 3262: 構文解析された場合に、最初に@var{x}と@var{y}がグループ化されるか、
 3263: それとも@var{y}と@var{z}がグループ化されるかを指定します。
 3264: @code{%left}は、左結合性、つまり@var{x}と@var{y}が先に結合されることを
 3265: 指定します。@code{%right}は、右結合性、つまり、
 3266: @var{y}と@var{z}が先に結合されることを指定します。
 3267: @code{%nonassoc}は、無結合性を指定し、その場合、
 3268: @samp{@var{x} @var{op} @var{y} @var{op} @var{z}}は
 3269: 構文エラーとみなされます。
 3270: 
 3271: @item
 3272: 演算子の優先順位は、その演算子が他の演算子とともに使われた場合の
 3273: 動作を指定します。同一の優先順位宣言で宣言されたすべてのトークンは、
 3274: 同じ優先順位を持ち、その結合性にしたがって処理されます。
 3275: 2個のトークンが別々の優先順位宣言で宣言されているならば、
 3276: 文法ファイルの中で後で宣言されたほうの演算子が強い優先順位を持ちます。
 3277: 
 3278: @end itemize
 3279: 
 3280: 
 3281: @node Union Decl, Type Decl, Precedence Decl, Declarations
 3282: @subsection 値型の集合
 3283: @cindex declaring value types
 3284: @cindex value types, declaring
 3285: @findex %union
 3286: @cindex 値型の宣言
 3287: @cindex 宣言, 値型
 3288: 
 3289: @code{%union}宣言は、意味値に対して可能なデータ型すべての集合を指定します。
 3290: キーワード@code{%union}に続いて、C言語における共用体の宣言と同様に、
 3291: ブレースで囲んだ宣言の並びを書きます。
 3292: 
 3293: 例を示します。
 3294: 
 3295: @example
 3296: @group
 3297: %union @{
 3298:   double val;
 3299:   symrec *tptr;
 3300: @}
 3301: @end group
 3302: @end example
 3303: 
 3304: これは、2つの選択可能な型@code{double}と@code{symrec *}があると、
 3305: 宣言しています。
 3306: それぞれの型には、名前@code{val}と@code{tptr}が与えられています。
 3307: これらの名前は、@code{%token}と@code{type}宣言の中で、
 3308: 終端記号あるいは非終端記号に対する型を選ぶために使えます
 3309: (@pxref{Type Decl, ,Nonterminal Symbols})。
 3310: 
 3311: C言語での共用体宣言とは異なり、閉じブレースの後にセミコロンを
 3312: @emph{書いてはいけない}ことに注意してください。
 3313: 
 3314: 
 3315: @node Type Decl, Expect Decl, Union Decl, Declarations
 3316: @subsection 非終端記号
 3317: @cindex declaring value types, nonterminals
 3318: @cindex value types, nonterminals, declaring
 3319: @findex %type
 3320: @cindex 値型の宣言, 非終端記号
 3321: @cindex 宣言, 非終端記号の値型
 3322: @cindex 非終端記号, 値型の宣言
 3323: 
 3324: @code{%union}を複数の値型を指定するために使うならば、
 3325: 値を持つ各非終端記号の値型を宣言する必要があります。
 3326: そのためには、次のように@code{%type}宣言を使います。
 3327: 
 3328: @example
 3329: %type <@var{type}> @var{nonterminal}@dots{}
 3330: @end example
 3331: 
 3332: ここで、@var{nonterminal}は非終端記号の名前で、
 3333: @var{type}は@code{%union}で指定した名前の中からあなたが選んだものです
 3334: (@pxref{Union Decl, ,The Collection of Value Types})。
 3335: 同じ値型を持つ任意の数の非終端記号を、
 3336: 1つの@code{%type}宣言の中に記述できます。
 3337: その場合、記号名を空白で区切ってください。
 3338: 
 3339: 同様に終端記号の値型の宣言も可能です。
 3340: そのためには、終端記号の宣言の中で、同じ@code{<@var{type}>}の
 3341: 書式を使います。
 3342: すべてのトークン宣言で、@code{<@var{type}>}が許可されています。
 3343: 
 3344: 
 3345: @node Expect Decl, Start Decl, Type Decl, Declarations
 3346: @subsection 衝突警告の回避
 3347: @cindex suppressing conflict warnings
 3348: @cindex preventing warnings about conflicts
 3349: @cindex warnings, preventing
 3350: @cindex conflicts, suppressing warnings of
 3351: @findex %expect
 3352: @cindex 衝突警告の回避
 3353: @cindex 回避, 衝突警告
 3354: @cindex 警告, 衝突
 3355: @cindex 衝突, 警告の回避
 3356: 
 3357: 文法の中に衝突(@pxref{Shift/Reduce, ,Shift/Reduce Conflicts})があると、
 3358: Bisonは通常警告を表示します。
 3359: しかし、実際の文法のほとんどは、無害なシフト還元衝突を含み、
 3360: その衝突は、予測可能な方法で回避できますが、除去は困難です。
 3361: 衝突の数が変わらないかぎり、このような衝突の警告は
 3362: 抑制させるべきです。
 3363: そのために、@code{%expect}宣言を使います。
 3364: 
 3365: 次のように宣言します。
 3366: 
 3367: @example
 3368: %expect @var{n}
 3369: @end example
 3370: 
 3371: ここで、@var{n}は10進の整数です。
 3372: この宣言によって、@var{n}個のシフト還元衝突があって、
 3373: 還元/還元衝突がなければ、警告が表示されません。
 3374: シフト還元衝突の数が@var{n}でなかったり、
 3375: 1つでも還元/還元衝突があった場合は、通常の警告が表示されます。
 3376: 
 3377: 一般に、次のような手順で@code{%expect}を使います。
 3378: 
 3379: @itemize @bullet
 3380: @item
 3381: @code{%expect}なしで文法ファイルをコンパイルします。
 3382: 衝突が起こる位置の詳細な目録を得るために、@samp{-v}オプションを指定します。
 3383: Bisonは、衝突の数も表示します。
 3384: 
 3385: @item
 3386: 衝突のそれぞれについて、Bisonの省略時の解決方法が、
 3387: あなたの望みどおりであるか、確かめます。
 3388: もし不都合があれば、文法ファイルを書き直して、最初に戻ります。
 3389: 
 3390: @item
 3391: Bisonが表示した衝突の数@var{n}を書き写して、
 3392: @code{%expect}宣言を追加します。
 3393: 
 3394: @end itemize
 3395: 
 3396: すると、Bisonはチェックした衝突について文句をいわなくなりますが、
 3397: 文法ファイルを書き換えて衝突の数が変わると、
 3398: 再び警告を表示します。
 3399: 
 3400: 
 3401: @node Start Decl, Pure Decl, Expect Decl, Declarations
 3402: @subsection 開始記号
 3403: @cindex declaring the start symbol
 3404: @cindex start symbol, declaring
 3405: @cindex default start symbol
 3406: @findex %start
 3407: @cindex 開始記号の宣言
 3408: @cindex 宣言, 開始記号
 3409: @cindex 省略時開始記号
 3410: 
 3411: Bisonは、文法定義部にある最初の非終端記号を、
 3412: 省略時の開始記号と仮定します。
 3413: 次のような@code{%start}宣言で、明示的に開始記号を指定できます。
 3414: 
 3415: @example
 3416: %start @var{symbol}
 3417: @end example
 3418: 
 3419: 
 3420: @node Pure Decl, Decl Summary, Start Decl, Declarations
 3421: @subsection 純粋(再入可能)構文解析器
 3422: @cindex reentrant parser
 3423: @cindex pure parser
 3424: @findex %pure_parser
 3425: @cindex 再入可能構文解析器
 3426: @cindex 純粋構文解析器
 3427: 
 3428: @dfn{再入可能(reentrant)}プログラムとは、進路を変えないプログラム、
 3429: いいかえれば、完全に@dfn{純粋な(pure)}(読み出し専用)コードからなる
 3430: プログラムです。
 3431: @footnote{【訳注】ある手続きの終了を待たずに、その手続きを再度呼び出せる
 3432: ことでもあります。}
 3433: 再入可能性は、非同期実行が可能な場合に重要です。
 3434: たとえば、再入可能でないプログラムを、
 3435: シグナルハンドラから呼び出すことは危険です。マルチスレッド制御システムでは、
 3436: 再入不能プログラムはインターロックからしか呼び出せません。
 3437: 
 3438: 通常は、Bisonは再入可能でない構文解析器を生成します。
 3439: これはほとんどの使用に合い、YACCとの互換性も保ちます。
 3440: (標準のYACCインターフェースは継続的に非再入可能であります。
 3441: というのは、@code{yylex}、@code{yylval} や @code{yylloc} との通信に
 3442: 静的に確保された変数
 3443: @footnote{【訳注】他のソースファイルから見えないとう意味ではなく、
 3444: メモリ上の固定番地に置かれるという意味。}
 3445: を使うからです。
 3446: 
 3447: 代わりに、純粋な、再入可能な構文解析器を生成することができます。
 3448: 次のような@code{%pure_parser} Bison宣言は、
 3449: 再入可能な構文解析器を生成します。
 3450: 
 3451: @example
 3452: %pure_parser
 3453: @end example
 3454: 
 3455: この宣言によって、上記の2個の通信用変数@code{yylval}と@code{yylloc}が、
 3456: @code{yyparse}の局所変数になり、
 3457: @code{yylex}字句解析関数を呼び出す方法が変わります。
 3458: 詳細については、@xref{Pure Calling, ,Calling Conventions for Pure Parsers}。
 3459: @code{yyparse}の中の@code{yynerrs}変数も局所変数になります
 3460: (@pxref{Error Reporting, ,The Error Reporting Function @code{yyerror}})。
 3461: @code{yypase}関数自体を呼び出す方法は変わりません。
 3462: 
 3463: 解析器が純粋かどうかは文法規則には全く関係しません。
 3464: 全ての有効な文法から、純粋な解析器と非再入可能な解析器の
 3465: どちらかを生成するこができます。
 3466: 
 3467: @node Decl Summary,  , Pure Decl, Declarations
 3468: @subsection Bison宣言の要約
 3469: @cindex Bison declaration summary
 3470: @cindex declaration summary
 3471: @cindex summary, Bison declaration
 3472: @cindex Bison宣言の要約
 3473: @cindex 宣言の要約
 3474: @cindex 要約, Bison宣言
 3475: 
 3476: Bison宣言の要約を示します。
 3477: 
 3478: @table @code
 3479: @item %union
 3480: 意味値が持ちうるデータ型の集合を宣言します
 3481: (@pxref{Union Decl, ,The Collection of Value Types})。
 3482: 
 3483: @item %token
 3484: 優先順位と結合性を指定せずに、終端記号(トークン型名)を宣言します
 3485: (@pxref{Token Decl, ,Token Type Names})。
 3486: 
 3487: @item %right
 3488: 右結合的な終端記号(トークン型名)を宣言します
 3489: (@pxref{Precedence Decl, ,Operator Precedence})。
 3490: 
 3491: @item %left
 3492: 左結合的な終端記号(トークン型名)を宣言します
 3493: (@pxref{Precedence Decl, ,Operator Precedence})。
 3494: 
 3495: @item %nonassoc
 3496: 結合性がない、つまり、結合して使おうとすると構文エラーになる、
 3497: 終端記号(トークン型名)を宣言します
 3498: (@pxref{Precedence Decl, ,Operator Precedence})。
 3499: 
 3500: @item %type
 3501: 非終端記号に対する意味値の型を宣言します
 3502: (@pxref{Type Decl, ,Nonterminal Symbols})。
 3503: 
 3504: @item %start
 3505: 文法の開始記号を宣言します
 3506: (@pxref{Start Decl, ,The Start-Symbol})。
 3507: 
 3508: @item %expect
 3509: 予想されるシフト還元衝突の数を宣言します
 3510: (@pxref{Expect Decl, ,Suppressing Conflict Warnings})。
 3511: 
 3512: @item %pure_parser
 3513: 純粋な(再入可能な)構文解析器を生成します
 3514: (@pxref{Pure Decl, ,A Pure (Reentrant) Parser})。
 3515: 
 3516: @item %no_lines
 3517: 構文解析器ファイルに、@code{#line}プリプロセッサディレクティブを生成しません。
 3518: Bisonは、通常、Cコンパイラとデバッガがエラーとあなたのソースファイル
 3519: (文法ファイル)を関連づけられるように、構文解析器ファイルに
 3520: @code{#line}ディレクティブを書き込みます。
 3521: @code{%no_lines}宣言は、エラーを構文解析器ファイルの行数と関連づけ、
 3522: 構文解析器ファイルをそれ自身で独立したソースファイルと
 3523: みなすことを意味します。
 3524: 
 3525: @item %raw
 3526: 通常、出力ファイル@file{@var{name}.h}は、
 3527: Yacc互換トークン番号を定義します。
 3528: このオプションが指定されると、代わりに、Bison内部の番号が使われます
 3529: (Yacc互換番号は、1文字リテラルトークンを除いて、257から始まりますが、
 3530: Bison内部のトークン番号は常に3から始まる連番になります)。
 3531: 
 3532: @item %token_table
 3533: 構文解析器ファイルの中に、トークン名の表を生成します。
 3534: その表の名前は@code{yytname}で、@code{yytname[@var{i}]}が
 3535: Bison内部トークン番号@var{i}のトークンの名前です。
 3536: 最初の3個の要素は常に、@code{"$"}、@code{"error"}、@code{"$illegal"}で、
 3537: この後に文法ファイルで定義された記号が続きます。
 3538: 
 3539: 表の中で、1文字リテラルトークンにはシングルクォート記号が、
 3540: 文字列リテラルトークンにはダブルクォート記号が含まれます。
 3541: たとえば、@code{"'+'"}は1文字リテラルトークンで、
 3542: @code{"\"<=\""}は文字列リテラルトークンです。
 3543: 文字列リテラルトークンのすべての文字はそのまま表に現れ、
 3544: ダブルクォート記号もエスケープされません。
 3545: たとえば、トークンが3文字@samp{*"*}からなれば、
 3546: @code{yytname}中の文字列は@samp{"*"*"}となります
 3547: (Cでは@code{"\"*\"*\""}と書きます)。
 3548: 
 3549: @code{%token_table}を指定すると、Bisonは、マクロ
 3550: @code{YYNTOKENS}、@code{YYNNTS}、@code{YYNRULES}、@code{YYNSTATES}の
 3551: 定義も生成します。
 3552: 
 3553: @table @code
 3554: @item YYNTOKENS
 3555: 最大のトークン番号+1。
 3556: @item YYNNTS
 3557: 非終端記号の数。
 3558: @item YYNRULES
 3559: 文法規則の数。
 3560: @item YYNSTATES
 3561: 構文解析器の状態の数(@pxref{Parser States})。
 3562: @end table
 3563: @end table
 3564: 
 3565: 
 3566: @node Multiple Parsers,, Declarations, Grammar File
 3567: @section 同一プログラム中の複数の構文解析器
 3568: 
 3569: Bisonを使うプログラムのほとんどは、言語を1つだけ構文解析し、
 3570: したがって、Bison構文解析器を1つだけ含みます。
 3571: しかし、1つのプログラムで2種類以上の言語を構文解析したいときは、
 3572: どうすればよいでしょうか? そうするためには、@code{yyparse}、@code{yylval}
 3573: などの2重定義の衝突を防ぐ必要があります。
 3574: 
 3575: これを容易にする方法が、オプション@samp{-p @var{prefix}}の利用です
 3576: (@pxref{Invocation, ,Invoking Bison})。
 3577: これによって、Bison構文解析器のインターフェイス関数と変数の名前が、
 3578: @samp{yy}で始まる代わりに@var{prefix}で始まります。
 3579: これでそれぞれの構文解析器に、衝突しないような異なる名前を与えられます。
 3580: 
 3581: 変更される名前は、
 3582: @code{yyparse}、@code{yylex}、@code{yyerror}、@code{yynerrs}、
 3583: @code{yylval}、@code{yychar}、@code{yydebug}で全部です。
 3584: たとえば、@samp{-p c}オプションを使えば、これらの名前は、
 3585: @code{cparse}、@code{clex}などに変わります。
 3586: 
 3587: @strong{Bisonに関連する上記以外の変数とマクロのすべての
 3588: 名前は変わりません。}これらは、広域ではないので、
 3589: 異なる構文解析器で同じ名前が使われても衝突しません。
 3590: たとえば、@code{YYSTYPE}の名前は変わりませんが、
 3591: この定義は構文解析器ごとに異なる方法で行われるので、問題ありません
 3592: (@pxref{Value Type, ,Data Types of Semantic Values})。
 3593: 
 3594: @samp{-p}オプションは、さらに、構文解析器ソースファイルの始めで、
 3595: @code{yyparse}を@code{@var{prefix}parse}と定義するように、
 3596: マクロを定義します。
 3597: この結果、構文解析器ソースファイル全体で、ある名前を別の名前に変えます。
 3598: 
 3599: 
 3600: @node Interface, Algorithm, Grammar File, Top
 3601: @chapter 構文解析器のC言語インターフェイス
 3602: @cindex C-language interface
 3603: @cindex interface
 3604: @cindex C言語インターフェイス
 3605: @cindex インターフェイス
 3606: 
 3607: Bison構文解析器の正体は、@code{yyparse}という名前のCの関数です。
 3608: ここでは、@code{yyparse}とほかに使う必要がある関数の間の
 3609: インターフェイスの方法を示します。
 3610: 
 3611: 構文解析器の内部では、多くの@samp{yy}または@samp{YY}で始まるCの識別子が
 3612: 使われていることに注意してください。
 3613: 本書で説明しているものを除いて、そのような識別子を
 3614: 文法ファイルのアクションや追加のCプログラムの中で使うと、
 3615: 問題が起きるでしょう。
 3616: 
 3617: @menu
 3618: * Parser Function::   @code{yyparse}の呼び方と、それが返すもの.
 3619: * Lexical::           トークンを読み込む関数@code{yylex}を提供しなければ
 3620:                         ならない.
 3621: * Error Reporting::   関数@code{yyerror}を提供しなければならない.
 3622: * Action Features::   アクションで使える特別な機能.
 3623: @end menu
 3624: 
 3625: 
 3626: @node Parser Function, Lexical,  , Interface
 3627: @section 構文解析器関数@code{yyparse}
 3628: @findex yyparse
 3629: 
 3630: 構文解析を始めるには、関数@code{yyparse}を呼び出します。
 3631: この関数は、トークンを読み、アクションを実行し、最後には入力ファイルの
 3632: 終わりに達するか回復不可能な構文エラーに達して、戻ります。
 3633: 読み込みを打ち切って@code{yyparse}関数から戻るような
 3634: アクションを書くことも可能です。
 3635: 
 3636: 構文解析が成功する、つまり入力ファイルの終わりに達すると、
 3637: @code{yyparse}からの戻り値が0になります。
 3638: 
 3639: 構文解析が失敗する、つまり構文エラーが発生すると、
 3640: 戻り値が1になります。
 3641: 
 3642: アクションの中で、次のマクロを使って、
 3643: @code{yyparse}からただちに戻れます。
 3644: 
 3645: @table @code
 3646: @item YYACCEPT
 3647: @findex YYACCEPT
 3648: 成功の印である戻り値0をともなって、ただちに戻ります。
 3649: 
 3650: @item YYABORT
 3651: @findex YYABORT
 3652: 失敗の印である戻り値1をともなって、ただちに戻ります。
 3653: 
 3654: @end table
 3655: 
 3656: 
 3657: @node Lexical, Error Reporting, Parser Function, Interface
 3658: @section 字句解析器関数@code{yylex}
 3659: @findex yylex
 3660: @cindex lexical analyzer
 3661: @cindex 字句解析器
 3662: 
 3663: @dfn{字句解析器(lexical analyzer)}関数@code{yylex}は、
 3664: 入力からトークンを認識し、構文解析器に返します。
 3665: Bisonはこの関数を自動的に生成しないので、
 3666: @code{yyparse}から呼び出されるように@code{yylex}を書く必要があります。
 3667: 関数@code{yylex}は``lexical scanner''と呼ばれることもあります。
 3668: 
 3669: 単純なプログラムでは、よく文法ファイルの最後で@code{yylex}を
 3670: 定義します。@code{yylex}が別のソースファイルの中で定義する場合は、
 3671: そこでトークン型マクロ定義を使えるように準備する必要があります。
 3672: そのためには、@samp{-d}オプションを指定してBisonを実行してください。
 3673: すると、マクロ定義がヘッダファイル@file{@var{name}.tab.h}に
 3674: 書き込まれ、それを必要とするソースファイルにインクルードできます。
 3675: @xref{Invocation, ,Invoking Bison}。
 3676: 
 3677: @menu
 3678: * Calling Convention::  @code{yyparse}が@code{yylex}を呼ぶ方法.
 3679: * Token Values::      @code{yylex}がどのように読み込んだトークンの
 3680:                         意味値を返さなければならないか.
 3681: * Token Positions::   アクションが望むときに、どのように@code{yylex}が
 3682:                         テキストの位置(行数など)を返さなければならない
 3683:                         か。
 3684: * Pure Calling::      純粋な構文解析器で呼び出し型の習慣がどのように
 3685:                         違うか (@pxref{Pure Decl, ,A Pure (Reentrant) Parser}).
 3686: @end menu
 3687: 
 3688: 
 3689: @node Calling Convention, Token Values,  , Lexical
 3690: @subsection @code{yylex}を呼び出す方法
 3691: 
 3692: @code{yylex}が返す値は、見つかったトークンの型に対する番号で、
 3693: 入力ファイルの終わりに達した場合には0を返します。
 3694: 
 3695: トークンが文法規則の中で名前で参照される場合、
 3696: 構文解析器ファイルの中でのその名前は、
 3697: トークン型に対する適切な番号にCのマクロとして定義されます。
 3698: したがって、@code{yylex}は型を示すためにその名前を使用できます。
 3699: @xref{Symbols}。
 3700: 
 3701: 文法規則の中でトークンが1文字リテラルとして参照される場合には、
 3702: その文字の文字符号がトークン型に対する番号でもあります。
 3703: そこで、@code{yylex}は、単純に文字符号を返します。
 3704: しかし、戻り値0は入力ファイルの終わりを意味するので、
 3705: ヌル文字(@code{'\0'})の文字符号を返してはいけません。
 3706: 
 3707: 以下に例を示します。
 3708: 
 3709: @example
 3710: yylex ()
 3711: @{
 3712:   @dots{}
 3713:   if (c == EOF)     /* ファイルの終わりか調べる。 */
 3714:     return 0;
 3715:   @dots{}
 3716:   if (c == '+' || c == '-')
 3717:     return c;      /* `+' に対するトークン型が '+' であると仮定する。 */
 3718:   @dots{}
 3719:   return INT;      /* トークン型を返す。 */
 3720:   @dots{}
 3721: @}
 3722: @end example
 3723: 
 3724: このようなインターフェイスは、
 3725: @code{lex}が生成した字句解析器を、
 3726: @code{yylex}の定義を変えずに使えるように設計されています。
 3727: 
 3728: 文法規則が文字列リテラルトークンを使っている場合には、
 3729: @code{yylex}がそれに対するトークン型番号を使う、
 3730: 2つの方法があります。
 3731: 
 3732: @itemize @bullet
 3733: @item
 3734: 文法が文字列リテラルトークンに対する別名として記号トークン名を
 3735: 定義しているならば、@code{yylex}はその記号名を他のトークンの記号名と
 3736: 同様に使えます。この場合、文法ファイルの中での文字列リテラルトークンの
 3737: 利用は、@code{yylex}にまったく影響しません。
 3738: 
 3739: @item
 3740: @code{yylex}は、@code{yytname}表の中で、
 3741: 複数文字トークンを見つけられます。
 3742: トークンに対する表の添え字は、そのトークン型の番号です。
 3743: 複数文字トークンは@code{yytname}の中にダブルクォート記号で囲まれて
 3744: 記憶されます。
 3745: トークンに含まれる文字はエスケープされず、
 3746: 表の中の文字列にそのまま書き込まれています。
 3747: 
 3748: トークンを構成する文字列が@code{token_buffer}に記憶されていると仮定して、
 3749: @code{yytname}からトークンを探し出すプログラムを示します。
 3750: 
 3751: @smallexample
 3752: for (i = 0; i < YYNTOKENS; i++)
 3753:   @{
 3754:     if (yytname[i] != 0
 3755:         && yytname[i][0] == '"'
 3756:         && strncmp (yytname[i] + 1, token_buffer,
 3757:                     strlen (token_buffer))
 3758:         && yytname[i][strlen (token_buffer) + 1] == '"'
 3759:         && yytname[i][strlen (token_buffer) + 2] == 0)
 3760:       break;
 3761:   @}
 3762: @end smallexample
 3763: 
 3764: @code{yytname}表は、@code{%token_table}宣言をした場合にのみ生成されます。
 3765: @xref{Decl Summary}。
 3766: 
 3767: @end itemize
 3768: 
 3769: 
 3770: @node Token Values, Token Positions, Calling Convention, Lexical
 3771: @subsection トークンの意味値
 3772: 
 3773: @vindex yylval
 3774: 通常の再入可能でない構文解析器では、
 3775: トークンの意味値が広域変数@code{yylval}に代入される必要があります。
 3776: 意味値に対してただ1つのデータ型を使っている場合には、
 3777: @code{yylval}の型もそうです。
 3778: したがって、たとえば、宣言を省略して型が@code{int}ならば、
 3779: 次のように書けます。
 3780: 
 3781: @example
 3782: @group
 3783:   @dots{}
 3784:   yylval = value;  /* 値をBisonスタックに積む。 */
 3785:   return INT;      /* トークン型を返す。 */
 3786:   @dots{}
 3787: @end group
 3788: @end example
 3789: 
 3790: 複数のデータ型を使っている場合には、
 3791: @code{%union}宣言で作られた共用体が@code{yylval}の型になります
 3792: (@pxref{Union Decl, ,The Collection of Value Types})。
 3793: そこで、トークンの値を代入するには、
 3794: 共用体のメンバの名前を指定する必要があります。
 3795: @code{%union}宣言の例を示します。
 3796: 
 3797: @example
 3798: @group
 3799: %union @{
 3800:   int intval;
 3801:   double val;
 3802:   symrec *tptr;
 3803: @}
 3804: @end group
 3805: @end example
 3806: 
 3807: すると、@code{yylex}の中のプログラムは次のようになります。
 3808: 
 3809: @example
 3810: @group
 3811:   @dots{}
 3812:   yylval.intval = value; /* 値をBisonスタックに積む。 */
 3813:   return INT;          /* トークン型を返す。 */
 3814:   @dots{}
 3815: @end group
 3816: @end example
 3817: 
 3818: 
 3819: @node Token Positions, Pure Calling, Token Values, Lexical
 3820: @subsection トークンのテキスト中の位置
 3821: 
 3822: @vindex yylloc
 3823: アクションの中で@samp{@@@var{n}}機能
 3824: (@pxref{Action Features, ,Special Features for Use in Actions})を
 3825: 使っている場合には、トークンとグループのテキスト中の位置を
 3826: 見失わないように、@code{yylex}の中で位置情報を提供する必要があります。
 3827: 関数@code{yyparse}は、ちょうど解析されたトークンのテキスト中の位置が、
 3828: 広域変数@code{yylloc}に記憶されていると仮定します。
 3829: そこで、@code{yylex}は、@code{yyloc}に正しいデータを記憶する必要があります。
 3830: 変数@code{yylloc}は構造体で、アクションの中で使われる場合にのみ、
 3831: メンバを初期化する必要があります。
 3832: メンバは、@code{first_line}、@code{first_column}、
 3833: @code{last_line}、@code{last_column}の4つです。
 3834: この機能を使うと、構文解析器が著しく遅くなることに注意してください。
 3835: 
 3836: @tindex YYLTYPE
 3837: @code{yylloc}のデータ型は、@code{YYLTYPE}という名前を持っています。
 3838: 
 3839: 
 3840: @node Pure Calling,  , Token Positions, Lexical
 3841: @subsection 再入可能構文解析器を呼び出す方法
 3842: 
 3843: 純粋な、つまり再入可能な、構文解析器を生成するために、
 3844: @code{%pure_parser}をBison宣言すると、広域変数@code{yylval}と
 3845: @code{yylloc}を使えなくなります
 3846: (@pxref{Pure Decl, ,A Pure (Reentrant) Parser})。
 3847: このような構文解析器では、2つの広域変数の代わりに、
 3848: @code{yylex}への引数として渡されるポインタを使います。
 3849: @code{yylex}を次のように宣言し、
 3850: これらのポインタを通して情報を受け渡しする必要があります。
 3851: 
 3852: @example
 3853: yylex (lvalp, llocp)
 3854:      YYSTYPE *lvalp;
 3855:      YYLTYPE *llocp;
 3856: @{
 3857:   @dots{}
 3858:   *lvalp = value;  /* 値をBisonスタックに積む。  */
 3859:   return INT;      /* トークン型を返す。 */
 3860:   @dots{}
 3861: @}
 3862: @end example
 3863: 
 3864: 文法ファイルがテキスト中の位置を参照するための@samp{@@}機能を
 3865: 使っていない場合は、@code{YYLTYPE}は定義されません。
 3866: この場合、第2引数を省略し、@code{yylex}は
 3867: 1個の引数をともなって呼び出されます。
 3868: 
 3869: @vindex YYPARSE_PARAM
 3870: 再入可能な構文解析器を使っている場合、
 3871: 再入可能な方法で構文解析器に追加の引数を渡す方法があります。
 3872: そのためには、マクロ@code{YYPARSE_PARAM}を変数名として定義します。
 3873: すると、関数@code{yyparse}は、定義された名前で、型が@code{void *}の
 3874: 追加の引数を受け取ります。
 3875: 
 3876: @code{yyparse}を呼び出すときに、オブジェクトの番地を
 3877: @code{void *}型にキャストして渡します。
 3878: 文法のアクションは、ポインタを適切な型へのポインタへキャストし、
 3879: 逆参照して、オブジェクトの内容を参照できます。
 3880: 例を示します。
 3881: 
 3882: @example
 3883: %@{
 3884: struct parser_control
 3885: @{
 3886:   int nastiness;
 3887:   int randomness;
 3888: @};
 3889: 
 3890: #define YYPARSE_PARAM parm
 3891: %@}
 3892: @end example
 3893: 
 3894: 次のように構文解析器を呼び出します。
 3895: 
 3896: @example
 3897: struct parser_control
 3898: @{
 3899:   int nastiness;
 3900:   int randomness;
 3901: @};
 3902: 
 3903: @dots{}
 3904: 
 3905: @{
 3906:   struct parser_control foo;
 3907:   @dots{}  /* @r{@code{foo}に正しいデータを記憶}  */
 3908:   value = yyparse ((void *) &foo);
 3909:   @dots{}
 3910: @}
 3911: @end example
 3912: 
 3913: 文法アクションの中では、データを参照するために次のような式を使います。
 3914: 
 3915: @example
 3916: ((struct parser_control *) parm)->randomness
 3917: @end example
 3918: 
 3919: @vindex YYLEX_PARAM
 3920: @code{yylex}に追加の引数を渡したい場合には、
 3921: @code{YYPARSE_PARAM}と同様に、マクロ@code{YYLEX_PARAM}を定義します。
 3922: 例を示します。
 3923: 
 3924: @example
 3925: %@{
 3926: struct parser_control
 3927: @{
 3928:   int nastiness;
 3929:   int randomness;
 3930: @};
 3931: 
 3932: #define YYPARSE_PARAM parm
 3933: #define YYLEX_PARAM parm
 3934: %@}
 3935: @end example
 3936: 
 3937: そして、@code{yylex}が追加の引数、@code{parm}の値を受け取るように、
 3938: @code{yylex}を定義する必要があります
 3939: (型@code{YYLTYPE}のどの引数が渡されるかに応じて、
 3940: 引数の合計が2個または3個になります)。
 3941: 引数を正しいオブジェクト型として宣言できます。すなわち@code{void *}として
 3942: 宣言し、上記の番地を参照できます。
 3943: 
 3944: @code{YYPARSE_PARAM}を使わずに、@samp{%pure_parser}を使って、
 3945: 再入可能な構文解析器を生成することも可能です。
 3946: その場合、引数をつけずに@code{yyparse}を呼び出すべきです。
 3947: 
 3948: 
 3949: @node Error Reporting, Action Features, Lexical, Interface
 3950: @section エラー報告関数@code{yyerror}
 3951: @cindex error reporting function
 3952: @findex yyerror
 3953: @cindex parse error
 3954: @cindex syntax error
 3955: @cindex エラー報告関数
 3956: @cindex 構文解析エラー
 3957: @cindex 文法エラー
 3958: 
 3959: Bison構文解析器は、文法規則に適合しないトークンを読むたびに、
 3960: @dfn{構文解析エラー(parse error)}すなわち@dfn{文法エラー(syntax error)}を
 3961: 検出します。文法中のアクションは、マクロ@code{YYERROR}を使って、
 3962: 明示的にエラーを示せます
 3963: (@pxref{Action Features, ,Special Features for Use in Actions})。
 3964: 
 3965: Bison構文解析器は、@code{yyerror}という名前の関数を使って、
 3966: エラーを報告するようになっています。
 3967: 事前に用意が必要な
 3968: この関数は、文法エラーが発生するたびに、1個の引数をともなって、
 3969: @code{yyparse}から呼び出されます。
 3970: 構文解析エラーに対して、引数の文字列は通常@w{@code{"parse error"}}です。
 3971: 
 3972: @findex YYERROR_VERBOSE
 3973: Bison定義部(@pxref{Bison Declarations, ,The Bison Declarations Section})で、
 3974: マクロ@code{YYERROR_VERBOSE}を定義すると、
 3975: @w{@code{"parse error"}}の代わりに、
 3976: エラーを詳細に報告する文字列が用意されます。
 3977: マクロ@code{YYERROR_VERBOSE}の定義はなんでもかまいません。
 3978: 
 3979: 構文解析器は、もう1種類のエラーであるスタックオーバーフローを検出する
 3980: 可能性があります。これは、入力がきわめて深い入れ子からなっていると
 3981: 起こることがあります。Bison構文解析器は自動的にスタックの限界を大きく拡張し
 3982: ているので、スタックオーバーフローはめったに起きません。
 3983: しかし、もしスタックオーバーフローが起きれば、
 3984: @w{@code{"parser stack overflow"}}という
 3985: 文字列の引数をともなって、@code{yyerror}が呼び出されます。
 3986: 
 3987: 単純なプログラムでは、次の例のように@code{yyerror}を定義できます。
 3988: 
 3989: @example
 3990: @group
 3991: yyerror (s)
 3992:      char *s;
 3993: @{
 3994: @end group
 3995: @group
 3996:   fprintf (stderr, "%s\n", s);
 3997: @}
 3998: @end group
 3999: @end example
 4000: 
 4001: @code{yyerror}から戻った後、@code{yyparse}は、
 4002: 適切なエラー回復文法規則(@pxref{Error Recovery})があれば、
 4003: エラーからの回復を試みます。
 4004: もし、回復が不可能ならば、@code{yyparse}は即座に1を返します。
 4005: 
 4006: @vindex yynerrs
 4007: 変数@code{yynerrs}には、それまでに出くわした文法エラーの数が記憶されています。
 4008: 通常、この変数は広域変数です。
 4009: しかし、再入可能な構文解析器(@pxref{Pure Decl, ,A Pure (Reentrant) Parser})
 4010: を生成した場合には、アクションからのみ参照可能な局所変数になります。
 4011: 
 4012: 
 4013: @node Action Features,  , Error Reporting, Interface
 4014: @section アクション中で使える特別な機能
 4015: @cindex summary, action features
 4016: @cindex action fetures summary
 4017: @cindex 要約, アクション
 4018: @cindex アクションの要約
 4019:  
 4020: ここの表では、アクション中で有用な、Bisonの構造物、変数、
 4021: マクロを示します。
 4022: 
 4023: @table @samp
 4024: @item $$
 4025: 現在の規則で作られるグループに対する意味値を保持する変数のように働きます。
 4026: @xref{Actions}。
 4027: 
 4028: @item $@var{n}
 4029: 現在の規則の@var{n}番目の構成要素に対する意味値を保持する変数のように
 4030: 働きます。@xref{Actions}。
 4031: 
 4032: @item $<@var{typealt}>$
 4033: @code{$$}に似ていますが、@code{%union}宣言で指定された共用体の中の
 4034: @var{typealt}を選びます。
 4035: @xref{Action Types, ,Data Types of Values in Actions}。
 4036: 
 4037: @item $<@var{typealt}>@var{n}
 4038: @code{$@var{n}}に似ていますが、@code{%union}宣言で指定された共用体の中の
 4039: @var{typealt}を選びます。
 4040: @xref{Action Types, ,Data Types of Values in Actions}。
 4041: 
 4042: @item YYABORT;
 4043: @code{yyparse}からただちに戻り、失敗を示します。
 4044: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 4045: 
 4046: @item YYACCEPT;
 4047: @code{yyparse}からただちに戻り、成功を示します。
 4048: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 4049: 
 4050: @item YYBACKUP (@var{token}, @var{value});
 4051: @findex YYBACKUP
 4052: トークンを逆シフトします。
 4053: 1個の値を還元する規則の中で、先読みトークンがない場合にのみ、
 4054: このマクロが使えます。
 4055: このマクロは、トークン型が@var{token}で意味値が@var{value}のトークンを、
 4056: 先読みトークンとして格納し、この規則で還元されるはずだった値を捨てます。
 4057: 
 4058: 先読みトークンがすでにあるような、このマクロが無効な状況で
 4059: このマクロを使うと、メッセージ@samp{cannnot back up}をともなう
 4060: 文法エラーが報告され、通常のエラー回復が行われます。
 4061: 
 4062: どちらの場合も、アクションの残りの部分は実行されません。
 4063: 
 4064: @item YYEMPTY
 4065: @vindex YYEMPTY
 4066: 先読みトークンがない場合に、変数@code{yychar}に記憶されている値です。
 4067: 
 4068: @item YYERROR;
 4069: @findex YYERROR
 4070: ただちに文法エラーを発生させます。この文は、構文解析器がエラーを検出したように
 4071: エラー回復を始めますが、@code{yyerror}を呼び出さず、
 4072: メッセージは表示されません。
 4073: もし、エラーメッセージを表示したければ、@samp{YYERROR}文よりも先に、
 4074: 明示的に@code{yyerror}を呼び出してください。
 4075: @xref{Error Recovery}。
 4076: 
 4077: @item YYRECOVERING
 4078: このマクロの値は、字句解析器が文法エラーからの回復中ならば1、
 4079: そうでなければ0です。
 4080: @xref{Error Recovery}。
 4081: 
 4082: @item yychar
 4083: 現在の先読みトークンを含んでいる変数です
 4084: (再入可能構文解析器では、@code{yyparse}の局所変数です)。
 4085: 先読みトークンがない場合には、この変数に
 4086: @code{YYEMPTY}という値が入っています。
 4087: @xref{Look-Ahead, ,Look-Ahead Tokens}。
 4088: 
 4089: @item yyclearin;
 4090: 現在の先読みトークンを捨てます。エラー規則の中で有用です。
 4091: @xref{Error Recovery}。
 4092: 
 4093: @item yyerrok;
 4094: 後に続く文法エラーに対して、エラーメッセージの生成を再開します。
 4095: これは、エラー規則で特に重要です。
 4096: @xref{Error Recovery}。
 4097: 
 4098: @item @@@var{n}
 4099: @findex @@@var{n}
 4100: 現在の規則の第@var{n}要素の、行番号と列番号を含む、
 4101: 配列変数のように働きます。
 4102: 次のようなメンバがあります。
 4103: 
 4104: @example
 4105: struct @{
 4106:   int first_line, last_line;
 4107:   int first_column, last_column;
 4108: @};
 4109: @end example
 4110: 
 4111: たとえば、第3要素の開始行番号を知るには、
 4112: @samp{@@3.first_line}とします。
 4113: 
 4114: この構造体のメンバを有効な情報にするためには、
 4115: @code{yylex}がそれぞれのトークンに対して、
 4116: 情報を提供する必要があります。
 4117: 一部分のメンバだけが必要ならば、
 4118: @code{yylex}はそのメンバの値を設定するだけでかまいません。
 4119: @footnote{【訳注】@code{yylex}は、変数@code{yylloc}に、
 4120: トークンの位置情報を代入します。}
 4121: 
 4122: この機能を使うと、字句解析器が著しく遅くなります。
 4123: @end table
 4124: 
 4125: 
 4126: @node Algorithm, Error Recovery, Interface, Top
 4127: @chapter Bison構文解析器のアルゴリズム
 4128: @cindex Bison parser algorithm 
 4129: @cindex algorithm of parser
 4130: @cindex shifting
 4131: @cindex reduction
 4132: @cindex parser stack
 4133: @cindex stack, parser
 4134: @cindex Bison構文解析器のアルゴリズム
 4135: @cindex シフト
 4136: @cindex 還元
 4137: @cindex 構文解析器のスタック
 4138: @cindex スタック, 構文解析器
 4139: 
 4140: Bison構文解析器は、トークンを読むと、トークンの意味値とともにスタックに積みます。
 4141: このスタックを@dfn{構文解析器スタック(parser stack)}と呼びます。
 4142: トークンをスタックに積むことを、伝統的に
 4143: @dfn{シフト(shifting)}と呼びます。
 4144: 
 4145: たとえば、中間記法電卓が、@samp{1 + 5 *}をすでに読んでいて、
 4146: @samp{3}を受け取ったと仮定します。
 4147: スタックには4個の要素があり、トークンそれぞれがシフトされています。
 4148: 
 4149: しかし、スタックに常に読み込まれたトークンそれぞれに対する
 4150: 要素があるわけではありません。
 4151: 最後の@var{n}個のトークンとグループが文法規則に当てはまる場合には、
 4152: それらは規則に従って組み合わされます。
 4153: これを、@dfn{還元(reduction)}と呼びます。
 4154: スタックにあったトークンとグループは、
 4155: 規則の結果、つまり左側にある記号である、1個のグループに置き換えられます。
 4156: 規則のアクションの実行は、結果のグループの意味値を計算するので、
 4157: 還元の手順の1つです。
 4158: 
 4159: たとえば、中間記法電卓の構文解析器スタックの内容は次のようになります。
 4160: 
 4161: @example
 4162: 1 + 5 * 3
 4163: @end example
 4164: 
 4165: そして、入力された次のトークンが改行符号ならば、
 4166: 次の規則に従って、最後の3個の要素が15に還元されます。
 4167: 
 4168: @example
 4169: expr: expr '*' expr;
 4170: @end example
 4171: 
 4172: そして、スタックは3個の要素を持ちます。
 4173: 
 4174: @example
 4175: 1 + 15
 4176: @end example
 4177: 
 4178: この時点で、別の還元が可能になり、1個の値16を得ます。
 4179: そして、改行符号がシフトされます。
 4180: 
 4181: 構文解析器は、シフトと還元によって、入力全体を
 4182: 文法の開始記号である1個のグループに還元しようとします
 4183: (@pxref{Language and Grammar, ,Languages and Context-Free Grammars})。
 4184: 
 4185: この種類の構文解析器は、ボトムアップ構文解析器として知られています。
 4186: 
 4187: @menu
 4188: * Look-Ahead::        構文解析器は何をするかを決めるときに一つ先のトーク
 4189:                         ンを見る.
 4190: * Shift/Reduce::      衝突: シフトと還元の両方が有効なとき.
 4191: * Precedence::        演算子の優先順位は衝突を解決することで動作する.
 4192: * Contextual Precedence::  演算子の優先順位が文脈に依存するとき.
 4193: * Parser States::     構文解析器はスタック付きの有限状態機械.
 4194: * Reduce/Reduce::     同じ状況に2つの規則が適用可能なとき.
 4195: * Mystery Conflicts::  正しくないように見える還元/還元衝突.
 4196: * Stack Overflow::    スタックが一杯になったときに何が起こるうか. それを
 4197:                         避ける方法.
 4198: @end menu
 4199: 
 4200: 
 4201: @node Look-Ahead, Shift/Reduce,  , Algorithm
 4202: @section 先読みトークン
 4203: @cindex look-ahead token
 4204: @cindex 先読みトークン
 4205: 
 4206: Bison構文解析器は、必ずしも文法規則に適合する最後の@var{n}個のトークン
 4207: またはグループが見つかるとすぐに還元を行う@emph{わけではありません}。
 4208: そのような単純な方法は、多くの言語の処理に適さないからです。
 4209: その代わりに、還元が可能な場合に、構文解析器は次のトークンを
 4210: 「先読み」し、次に何をするべきかを決定します。
 4211: 
 4212: トークンが読まれると、それはすぐにシフトされるのではなく、
 4213: まず、@dfn{先読みトークン(look-ahead token)}になり、
 4214: スタックには置かれません。
 4215: 先読みトークンを残したまま、構文解析器が、スタック上のトークンまたは
 4216: グループに対して1個以上の還元を実行します。
 4217: それ以上の還元が起こりえない場合に、
 4218: 先読みトークンはスタックにシフトされます。
 4219: これは、すべての可能な還元が実行されたことを意味しません。
 4220: 先読みトークンのトークン型に応じて、
 4221: いくつかの規則は適用を遅らされているかもしれません。
 4222: 
 4223: 先読みが必要な簡単な例を示します。
 4224: 下記の3個の規則は、2項加算演算子、単項階乗演算子(@samp{!})、
 4225: グループのためのかっこを含みます。
 4226: 
 4227: @example
 4228: @group
 4229: expr:     term '+' expr
 4230:         | term
 4231:         ;
 4232: @end group
 4233: 
 4234: @group
 4235: term:     '(' expr ')'
 4236:         | term '!'
 4237:         | NUMBER
 4238:         ;
 4239: @end group
 4240: @end example
 4241: 
 4242: トークン@w{@samp{1 + 2}}が読み込まれてシフトされているときに、
 4243: 何が起きるでしょうか。もし、続くトークンが@samp{)}ならば、
 4244: 最初の3個のトークンは@code{expr}の形式に還元される必要があります。
 4245: これが、唯一有効な道です。
 4246: なぜならば、@samp{)}をシフトして、@w{@code{term ')'}}という記号列も
 4247: 生成可能ですが、どの規則もそのような記号列を許していないからです。
 4248: 
 4249: もし、続くトークンが@samp{!}ならば、それはただちにシフトされる必要があり、
 4250: @w{@samp{2 !}}から@code{term}が還元されます。
 4251: そうではなく、構文解析器がシフトの前に還元していれば、
 4252: @w{@samp{1 + 2}}が@code{expr}に還元されます。
 4253: しかし、そのような還元をしようとすると@code{expr '!'}という記号列を
 4254: スタックに生成しようとするので、@samp{!}をシフトするのは不可能です。
 4255: そのような記号列は許されません。
 4256: 
 4257: @vindex yychar
 4258: 現在の先読みトークンは、変数@code{yychar}に記憶されています
 4259: @xref{Action Features, ,Special Features for Use in Actions}。
 4260: 
 4261: 
 4262: @node Shift/Reduce, Precedence, Look-Ahead, Algorithm
 4263: @section シフト還元衝突
 4264: @cindex conflicts
 4265: @cindex shift/reduce conflicts
 4266: @cindex dangling else
 4267: @cindex else, dangling
 4268: @cindex 衝突
 4269: @cindex シフト還元衝突
 4270: @cindex ぶらさがりelse
 4271: @cindex else, ぶらさがり
 4272: 
 4273: 次の2個の規則で定められる、``if-then''と``if-then-else''文を持つ
 4274: 言語の構文解析について考えます。
 4275: 
 4276: @example
 4277: @group
 4278: if_stmt:
 4279:           IF expr THEN stmt
 4280:         | IF expr THEN stmt ELSE stmt
 4281:         ;
 4282: @end group
 4283: @end example
 4284: 
 4285: ここで、@code{IF}、@code{THEN}、@code{ELSE}は、
 4286: キーワードトークンを表す終端記号であると仮定します。
 4287: 
 4288: @code{ELSE}トークンが読まれて先読みトークンになったときに、
 4289: 入力が正しいと仮定して、スタックの内容はちょうど
 4290: 最初の規則で還元される右辺になっています。
 4291: しかし、いずれ起こるはずの第2の規則の還元のために、
 4292: @code{ELSE}トークンをシフトすることも有効です。
 4293: 
 4294: この、シフトと還元の両方が有効な場合を、
 4295: @dfn{シフト還元衝突(shift/reduce conflict)}と呼びます。
 4296: Bisonは、演算子優先規則宣言で特に指定されていないかぎり、
 4297: シフトを選ぶことで衝突を解決するように設計されています。
 4298: この理由を理解するために、別の選択肢と比較してみましょう。
 4299: 
 4300: 構文解析器は@code{ELSE}のシフトを選ぶので、その結果、
 4301: else節はもっとも内側のif文に対応し、次の2つの入力は等価になります。
 4302: 
 4303: @example
 4304: if x then if y then win (); else lose;
 4305: 
 4306: if x then do; if y then win (); else lose; end;
 4307: @end example
 4308: 
 4309: しかし、字句解析器がシフトでなく還元を選ぶと、その結果、
 4310: else節がもっとも外側のif文に対応し、次の2つの入力は等価になります。
 4311: 
 4312: @example
 4313: if x then if y then win (); else lose;
 4314: 
 4315: if x then do; if y then win (); end; else lose;
 4316: @end example
 4317: 
 4318: 文法があいまいに書かれているために、衝突が起きます。
 4319: つまり、入れ子になったif文について、どちらの構文解析結果も正当なのです。
 4320: 確立された習慣では、else節をもっとも内側のif文に対応させて、
 4321: あいまいさを解決しています。
 4322: これが、Bisonが還元よりもシフトを選ぶ理由です
 4323: (理想的には、あいまいでない文法を書くべきですが、この場合には困難です)。
 4324: この問題は、Algol 60の仕様の中に現れたのが最初で、
 4325: 「ぶらさがり@code{else}(dangling @code{else})」問題と呼ばれています。
 4326: 
 4327: 予測可能で正当なシフト還元衝突について、Bisonが警告を表示しないように、
 4328: @code{%expect @var{n}}宣言を使えます。
 4329: すると、ちょうど@var{n}個のシフト還元衝突があるかぎり、
 4330: 警告は表示されません。
 4331: @xref{Expect Decl, ,Suppressing Conflict Warnings}。
 4332: 
 4333: 上記の@code{if_stmt}の定義は、衝突をわざと発生させるために書きましたが、
 4334: 追加の規則がなければ実際には衝突が起きません。
 4335: 次に、実際に衝突を含む完全なBison入力ファイルの例を示します。
 4336: 
 4337: @example
 4338: @group
 4339: %token IF THEN ELSE variable
 4340: %%
 4341: @end group
 4342: @group
 4343: stmt:     expr
 4344:         | if_stmt
 4345:         ;
 4346: @end group
 4347: 
 4348: @group
 4349: if_stmt:
 4350:           IF expr THEN stmt
 4351:         | IF expr THEN stmt ELSE stmt
 4352:         ;
 4353: @end group
 4354: 
 4355: expr:     variable
 4356:         ;
 4357: @end example
 4358: 
 4359: 
 4360: @node Precedence, Contextual Precedence, Shift/Reduce, Algorithm
 4361: @section 演算子の優先順位
 4362: @cindex operator precedence
 4363: @cindex precedence of operators
 4364: @cindex 演算子の優先順位
 4365: @cindex 優先順位, 演算子
 4366: 
 4367: シフト還元衝突が起きる別の可能性は、算術式の中にあります。
 4368: この場合には、シフトの選択が望ましい解決策であるとは限りません。
 4369: どのような場合にシフトしてどのような場合に還元するべきか指定するために、
 4370: 演算子の優先順位についてのBison宣言を使えます。
 4371: 
 4372: @menu
 4373: * Why Precedence::    優先順位が必要なことを示す例.
 4374: * Using Precedence::  Bison文法で優先順位を指定する方法.
 4375: * Precedence Examples::  前の例でこれらの機能が使われた方法.
 4376: * How Precedence::    どのように動作するか.
 4377: @end menu
 4378: 
 4379: 
 4380: @node Why Precedence, Using Precedence,  , Precedence
 4381: @subsection 優先順位が必要な場合
 4382: 
 4383: 次のあいまいな文法の一部を見てください。
 4384: 入力@w{@samp{1 - 2 * 3}}が2通りに構文解析されうるので、
 4385: この文法はあいまいです。
 4386: 
 4387: @example
 4388: @group
 4389: expr:     expr '-' expr
 4390:         | expr '*' expr
 4391:         | expr '<' expr
 4392:         | '(' expr ')'
 4393:         @dots{}
 4394:         ;
 4395: @end group
 4396: @end example
 4397: 
 4398: 構文解析器が、@samp{1}、@samp{-}、@samp{2}というトークンを
 4399: 読み込んだと仮定します。構文解析器は、減算演算子の規則に従って、
 4400: これらのトークンを還元するべきでしょうか。
 4401: それは、次のトークンに依存します。
 4402: もちろん、次のトークンが@samp{)}ならば、還元する必要があります。
 4403: なぜならば、もしシフトすると、@w{@samp{- 2 )}}またはそれで始まる
 4404: 記号列を還元する必要が生じ、そのような規則はないからです。
 4405: しかし、次のトークンが@samp{*}または@samp{<}ならば、
 4406: シフトと還元のどちらも可能です。
 4407: どちらを選んでも構文解析を完了できますが、解析の結果は異なります。
 4408: 
 4409: Bison字句解析器がどちらの処理をすべきか決めるために、
 4410: 構文解析の結果を考慮する必要があります。
 4411: もし、次の演算子トークン@var{op}がシフトされるならば、
 4412: 還元して差を求める可能性を許すために、
 4413: @var{op}は最初に還元される必要があります。
 4414: その結果は、@w{@samp{1 - (2 @var{op} 3)}}となります。
 4415: 逆に、@var{op}をシフトする前に減算を還元するならば、
 4416: 結果は@w{@samp{(1 - 2) @var{op} 3}}となります。
 4417: 明らかに、シフトと還元のどちらが起こるべきかの選択は、
 4418: 演算子@samp{-}と@var{op}の相対的な優先順位に依存します。
 4419: @samp{*}は先にシフトされるべきですが、@samp{<}は違います。
 4420: 
 4421: @cindex associativity
 4422: @cindex 結合性
 4423: @w{@samp{1 - 2 - 5}}のような例ではどうなるでしょうか。
 4424: @w{@samp{(1 - 2) - 5}}と処理するべきでしょうか。
 4425: それとも、@w{@samp{1 - (2 - 5)}}と処理するべきでしょうか。
 4426: ほとんどの演算子については前者が適し、これを、
 4427: @dfn{左結合性(left association)}と呼びます。
 4428: 後者の@dfn{右結合性(right association)}は、代入演算子に適します。
 4429: 左結合性か右結合性かの判断は、スタックに@w{@samp{1 - 2}}が含まれ、
 4430: 先読みトークンが@samp{-}である場合の、シフトか還元かの選択です。
 4431: シフトを選ぶと、右結合的になります。
 4432: 
 4433: 
 4434: @node Using Precedence, Precedence Examples, Why Precedence, Precedence
 4435: @subsection 演算子の優先順位の指定
 4436: @findex %left
 4437: @findex %right
 4438: @findex %nonassoc
 4439: 
 4440: 演算子優先順位宣言@code{%left}と@code{%right}によって、
 4441: 演算子の優先順位と結合規則を指定できます。
 4442: どちらの宣言も、優先順位と結合規則を指定したい演算子である、
 4443: トークンの並びからなります。
 4444: @code{%left}宣言はすべての演算子を左結合的に、
 4445: @code{%right}宣言はすべての演算子を右結合的に宣言します。
 4446: 第3の選択肢は@code{%nonassoc}宣言で、これで宣言した演算子が
 4447: 続けて2回以上現れると、構文解析器が文法エラーを指摘します。
 4448: 
 4449: 異なる演算子の相対的な優先順位は、それらが宣言される順序で決まります。
 4450: 文法ファイルの中の最初の@code{%left}宣言または@code{%right}宣言で
 4451: 宣言された演算子が、もっとも低い優先順位を持ちます。
 4452: 後から宣言される演算子ほど、高い優先順位を持ちます。
 4453: 
 4454: 
 4455: @node Precedence Examples, How Precedence, Using Precedence, Precedence
 4456: @subsection 優先順位の例
 4457: 
 4458: 先ほどの例では、次のように宣言するべきでした。
 4459: 
 4460: @example
 4461: %left '<'
 4462: %left '-'
 4463: %left '*'
 4464: @end example
 4465: 
 4466: もっと複雑な例では、より多くの演算子を使うだけでなく、
 4467: 同じ優先順位を持つ演算子があります。
 4468: 次の例では、@code{'+'}演算子と@code{'-'}演算子が同じ優先順位を持ちます。
 4469: 
 4470: @example
 4471: %left '<' '>' '=' NE LE GE
 4472: %left '+' '-'
 4473: %left '*' '/'
 4474: @end example
 4475: 
 4476: (この例で、@code{NE}は「等しくない」演算子を表し、他も同様です。
 4477: これらのトークンは、2文字以上からなるので、
 4478: 1文字リテラルではなく名前で表されると仮定しています)
 4479: 
 4480: 
 4481: @node How Precedence,  , Precedence Examples, Precedence
 4482: @subsection 優先順位が働く仕組み
 4483: 
 4484: 優先順位宣言の最初の働きは、宣言された終端記号への優先順位の割り当てです。
 4485: 第2の働きは、規則に含まれる最後の終端記号が優先順位を示すように、
 4486: ある規則に優先順位を割り当てることです
 4487: (規則に対して、明示的に優先順位を指定することも可能です。
 4488: @xref{Contextual Precedence, ,Context-Dependent Precedence})。
 4489: 
 4490: 最後に、衝突の解決は、問題になっている規則の優先順位と、
 4491: 先読みトークンの優先順位の比較によって行われます。
 4492: もし、先読みトークンの優先順位が高ければ、還元されます。
 4493: もし、規則の優先順位が高ければ、シフトされます。
 4494: もし、優先順位が同じならば、その優先順位での結合規則によって決定されます。
 4495: @samp{-v}オプションを付けてBisonを実行し、冗長な出力ファイルを得ると、
 4496: どのように衝突が解決されているかがわかります
 4497: (@pxref{Invocation, ,Invoking Bison})。
 4498: 
 4499: すべての規則とトークンが優先順位を持っているとはかぎりません。
 4500: もし、規則と先読みトークンが優先順位を持っていなければ、
 4501: シフトが行われます。
 4502: 
 4503: 
 4504: @node Contextual Precedence, Parser States, Precedence, Algorithm
 4505: @section 文脈依存優先順位
 4506: @cindex context-dependent precedence
 4507: @cindex unary operator precedence
 4508: @cindex precedence, context-dependent
 4509: @cindex precedence, unary operator
 4510: @findex %prec
 4511: @cindex 文脈依存優先順位
 4512: @cindex 単項演算子の優先順位
 4513: @cindex 優先順位, 文脈依存
 4514: @cindex 優先順位, 単項演算子
 4515: 
 4516: しばしば、演算子の優先順位は文脈に依存します。
 4517: これは、最初は奇異に感じるかもしれませんが、
 4518: 実際によく起きていることなのです。
 4519: たとえば、通常、減算演算子(@samp{-})は、
 4520: 単項演算子としては非常に高い優先順位を持ちますが、
 4521: 2項演算子としては乗除算よりも低い優先順位を持ちます。
 4522: 
 4523: Bisonの優先順位宣言、@code{%left}、@code{%right}、@code{%nonassoc}は、
 4524: あるトークンに対して1回のみ使え、この方法では、
 4525: トークンは唯一の優先順位を宣言されます。
 4526: 文脈に依存する優先順位のためには、別の方法、すなわち、
 4527: @code{%prec}で規則を修飾する方法が必要になります。
 4528: 
 4529: @code{%prec}修飾子は、ある規則で使われるべき終端記号の優先順位を指定して、
 4530: その規則の優先順位を宣言します。
 4531: その記号がその規則の中以外に現れる必要はありません。
 4532: 修飾子の記法は、次のようになっています。
 4533: 
 4534: @example
 4535: %prec @var{terminal-symbol}
 4536: @end example
 4537: 
 4538: これは、規則の構成要素の後に書かれます。
 4539: これによって、通常の方法で導かれる優先順位に代わって、
 4540: @var{terminal-symbol}の優先順位を規則に割り当てます。
 4541: 規則の優先順位が変更されて、その規則が関係している衝突の解決に影響します
 4542: (@pxref{Precedence, ,Operator Precedence})。
 4543: 
 4544: @code{%prec}がどのように単項負記号を解決するかを示します。
 4545: まず、@code{UMINUS}という名前の終端記号に対する優先順位を宣言します。
 4546: この型のトークンは存在しませんが、
 4547: この記号が優先順位を表現するために使われます。
 4548: 
 4549: @example
 4550: @dots{}
 4551: %left '+' '-'
 4552: %left '*'
 4553: %left UMINUS
 4554: @end example
 4555: 
 4556: さて、@code{UNIMIS}の優先順位を、規則の中で使えます。
 4557: 
 4558: @example
 4559: @group
 4560: exp:    @dots{}
 4561:         | exp '-' exp
 4562:         @dots{}
 4563:         | '-' exp %prec UMINUS
 4564: @end group
 4565: @end example
 4566: 
 4567: 
 4568: @node Parser States, Reduce/Reduce, Contextual Precedence, Algorithm
 4569: @section 構文解析器の状態
 4570: @cindex finite-state machine
 4571: @cindex parser state
 4572: @cindex state (of parser)
 4573: @cindex 有限状態機械
 4574: @cindex 構文解析器の状態
 4575: @cindex 状態, 構文解析器
 4576: 
 4577: 関数@code{yyparse}は、有限状態機械を使って実装されています。
 4578: 構文解析器のスタックに積まれる値は、トークン型番号だけでなく、
 4579: スタックの先頭またはその近くにある終端記号と非終端記号の列を
 4580: 表現しています。現在の状態は、次にすべきことに関連する、
 4581: 今までの入力の情報全体の集まりです。
 4582: 
 4583: 先読みトークンが読まれるたびに、先読みトークンの型と
 4584: 現在の構文解析器の状態によって、表が引かれます。
 4585: この表の項目には、「先読みトークンをシフトしなさい」というような
 4586: ことが書かれています。この場合、その表の項目は、
 4587: 先読みトークンが構文解析器スタックのトップに置かれた、
 4588: 構文解析器の新しい状態をも示しています。
 4589: 「@var{n}番目の規則を使って還元しなさい」というような項目もあります。
 4590: これによって、決められた数のトークンまたはグループがスタックのトップから
 4591: 取り除かれ、1個のグループがスタックのトップに置かれます。
 4592: 言い換えると、その数の状態がスタックからポップされ、
 4593: 新しい1個の状態がスタックにプッシュされます。
 4594: 
 4595: これには、1つの例外があります。
 4596: 先読みトークンが現在の状態に対してエラーであるという項目もあります。
 4597: この場合には、エラー処理が起こります
 4598: (@pxref{Error Recovery})。
 4599: 
 4600: 
 4601: @node Reduce/Reduce, Mystery Conflicts, Parser States, Algorithm
 4602: @section 還元/還元衝突
 4603: @cindex reduce/reduce conflict
 4604: @cindex conflicts, reduce/reduce
 4605: @cindex 還元/還元衝突
 4606: @cindex 衝突, 還元/還元
 4607: 
 4608: 同一の入力列に対して2個以上の規則が適用可能であると、
 4609: 還元/還元衝突が起きます。
 4610: これは、通常、文法の重大なエラーを意味します。
 4611: 
 4612: 0個以上の@code{word}の並びをグループ化する、
 4613: 誤った試みの例を示します。
 4614: 
 4615: @example
 4616: sequence: /* 空 */
 4617:                 @{ printf ("empty sequence\n"); @}
 4618:         | maybeword
 4619:         | sequence word
 4620:                 @{ printf ("added word %s\n", $2); @}
 4621:         ;
 4622: 
 4623: maybeword: /* 空 */
 4624:                 @{ printf ("empty maybeword\n"); @}
 4625:         | word
 4626:                 @{ printf ("single word %s\n", $1); @}
 4627:         ;
 4628: @end example
 4629: 
 4630: エラーは、あいまいさにあります。
 4631: つまり、1個の@code{word}を@code{sequence}に構文解析する、
 4632: 2個以上の方法があります。
 4633: @code{word}は、@code{maybeword}に還元され、
 4634: 第2の規則によって@code{sequence}になりえます。
 4635: また、最初の規則で、空データが@code{sequence}に還元され、
 4636: それが第3の規則によって@code{word}と組み合わされて
 4637: @code{sequence}になりえます。
 4638: 
 4639: さらに、空データが@code{sequence}に還元される方法が2つ以上あります。
 4640: 第1の規則で直接還元される方法と、
 4641: @code{maybeword}を経由して第2の規則で還元される方法です。
 4642: 
 4643: この違いは、特定の入力が正当であるかどうかに関係ないので、
 4644: ささいなことに思えるかもしれません。
 4645: しかし、これは、どのアクションが実行されるかに影響します。
 4646: ある構文解析手順では第2の規則のアクションが実行され、
 4647: 別の構文解析手順では第1の規則のアクションと第3の規則のアクションが
 4648: 実行されます。
 4649: この例では、プログラムの出力が異なります。
 4650: 
 4651: Bisonは、最初に現れた文法を選ぶことで、還元/還元衝突を解決しますが、
 4652: これに頼ることは非常に危険です。
 4653: 還元/還元衝突のそれぞれは、人間によって解析され、
 4654: 通常は取り除かれるべきです。
 4655: @code{sequence}を定義する正しい方法を示します。
 4656: 
 4657: @example
 4658: sequence: /* 空 */
 4659:                 @{ printf ("empty sequence\n"); @}
 4660:         | sequence word
 4661:                 @{ printf ("added word %s\n", $2); @}
 4662:         ;
 4663: @end example
 4664: 
 4665: 還元/還元衝突を起こす、別のありがちなエラーの例を示します。
 4666: 
 4667: @example
 4668: sequence: /* 空 */
 4669:         | sequence words
 4670:         | sequence redirects
 4671:         ;
 4672: 
 4673: words:    /* 空 */
 4674:         | words word
 4675:         ;
 4676: 
 4677: redirects:/* 空 */
 4678:         | redirects redirect
 4679:         ;
 4680: @end example
 4681: 
 4682: ここは、@code{word}または@code{redirect}グループのどちらかを含む
 4683: 列の定義が目的です。
 4684: @code{sequence}、@code{words}、@code{redirects}それぞれ個別の
 4685: 定義にエラーはありません。しかし、3個を合わせると、あいまいになります。
 4686: 空の入力には、無限個の構文解析方法があります。
 4687: 
 4688: 空データが@code{words}になったと仮定しましょう。
 4689: それは、2個の@code{words}にも、3個の@code{words}にも、
 4690: 何個の@code{words}にもなりえます。
 4691: あるいは、1個の@code{words}に3個の@code{redirects}ともう1個の@code{word}が
 4692: 続くことも考えられます。同様に、無限の解釈が可能です。
 4693: 
 4694: これらの規則を直す方法が2つあります。
 4695: 第1に、1段階の列にする方法です。
 4696: 
 4697: @example
 4698: sequence: /* 空 */
 4699:         | sequence word
 4700:         | sequence redirect
 4701:         ;
 4702: @end example
 4703: 
 4704: 第2に、@code{words}と@code{redirects}が空になるのを防ぐ方法です。
 4705:  
 4706: @example
 4707: sequence: /* 空 */
 4708:         | sequence words
 4709:         | sequence redirects
 4710:         ;
 4711: 
 4712: words:    word
 4713:         | words word
 4714:         ;
 4715: 
 4716: redirects:redirect
 4717:         | redirects redirect
 4718:         ;
 4719: @end example
 4720: 
 4721: 
 4722: @node Mystery Conflicts, Stack Overflow, Reduce/Reduce, Algorithm
 4723: @section 不可解な還元/還元衝突
 4724: 
 4725: そうなるはずがないように見えるのに、ときどき
 4726: 還元/還元衝突が起きることがあります。
 4727: 例を示します。
 4728: 
 4729: @example
 4730: @group
 4731: %token ID
 4732: 
 4733: %%
 4734: def:    param_spec return_spec ','
 4735:         ;
 4736: param_spec:
 4737:              type
 4738:         |    name_list ':' type
 4739:         ;
 4740: @end group
 4741: @group
 4742: return_spec:
 4743:              type
 4744:         |    name ':' type
 4745:         ;
 4746: @end group
 4747: @group
 4748: type:        ID
 4749:         ;
 4750: @end group
 4751: @group
 4752: name:        ID
 4753:         ;
 4754: name_list:
 4755:              name
 4756:         |    name ',' name_list
 4757:         ;
 4758: @end group
 4759: @end example
 4760: 
 4761: この文法は、1個のトークンの先読みによって、構文解析できるように見えます。
 4762: たとえば、@code{pram_spec}が読まれた後で、
 4763: @code{ID}はカンマかセミコロンが続くならば@code{name}、
 4764: そうでなければ@code{type}となります。
 4765: 言い換えれば、この文法はLR(1)です。
 4766: 
 4767: @cindex LR(1)
 4768: @cindex LALR(1)
 4769: しかし、Bisonは、多くの構文解析器生成器と同様に、
 4770: すべてのLR(1)文法を扱えるわけではありません。
 4771: 前述の例では、@code{ID}の後で、そこが@code{param_spec}の先頭であるという
 4772: 文脈と、そこが@code{return_spec}の先頭であるという文脈は、
 4773: Bisonが同一であるとみなしてしまうほど似ています。
 4774: これらの文脈が似てしまう原因は、同じ規則の集合が有効になる、つまり、
 4775: @code{name}へ還元するための規則と、@code{type}へ還元するための規則の
 4776: 両方が有効なことです。
 4777: Bisonは、その規則が2つの文脈で異なる先読みトークンを要求するような、
 4778: 処理の段階を決定できず、両者から1つの構文解析器状態ができてしまいます。
 4779: 2個の文脈の組み合わせは、後で衝突を起こします。
 4780: 構文解析器の用語でいえば、この問題の発生は、
 4781: 文法がLALR(1)でないことを意味します。
 4782: 
 4783: 一般に、このような欠点は解決して、文書化するべきです。
 4784: しかし、この問題は本質的に解決困難です。
 4785: LR(1)文法を扱える構文解析器生成器は、作成困難で、
 4786: 生成される構文解析器が巨大になってしまいます。
 4787: 実用上、Bisonは今のままでも有用です。
 4788: 
 4789: このような問題が現れた場合に、混乱の元になっている2種類の構文解析器の
 4790: 状態を区別し、それらが違うという目印か何かを追加することによって、
 4791: しばしば問題を解決できます。
 4792: 前述の例では、次のように@code{return_spec}に規則を追加して、
 4793: 問題を解決できます。
 4794: 
 4795: @example
 4796: @group
 4797: %token BOGUS
 4798: @dots{}
 4799: %%
 4800: @dots{}
 4801: return_spec:
 4802:              type
 4803:         |    name ':' type
 4804:          /* この規則は決して使われない。  */
 4805:         |    ID BOGUS
 4806:         ;
 4807: @end group
 4808: @end example
 4809: 
 4810: @code{ID}の次で@code{return_spec}の先頭である文脈で、
 4811: 追加の規則が有効になる可能性を導入して、問題を解決しています。
 4812: この規則は、@code{param_spec}に関連する文脈では有効にならないので、
 4813: 2個の文脈は、異なる構文解析器状態を持ちます。
 4814: @code{BOGUS}は@code{yylex}によっては決して生成されないので、
 4815: 追加された規則は入力が実際に構文解析される方法には影響しません。
 4816: 
 4817: この具体例では、問題を解決する別の方法があります。
 4818: つまり、@code{return_spec}の規則を、@code{name}経由ではなく
 4819: @code{ID}を直接使うように書き換えるのです。
 4820: @code{return_spec}に対する規則は、@code{name}に対する規則ではなく、
 4821: @code{return_spec}に対する規則を有効にするので、
 4822: 2つの混乱していた文脈は異なる有効な規則の集まりを持ちます。
 4823: 
 4824: @example
 4825: param_spec:
 4826:              type
 4827:         |    name_list ':' type
 4828:         ;
 4829: return_spec:
 4830:              type
 4831:         |    ID ':' type
 4832:         ;
 4833: @end example
 4834: 
 4835: 
 4836: @node Stack Overflow,  , Mystery Conflicts, Algorithm
 4837: @section スタックオーバーフローと防ぎ方
 4838: @cindex stack overflow
 4839: @cindex parser stack overflow
 4840: @cindex overflow of parser stack
 4841: @cindex スタックオーバーフロー
 4842: @cindex 構文解析器のスタックオーバーフロー
 4843: @cindex オーバーフロー, 構文解析器のスタック
 4844: 
 4845: Bison構文解析器のスタックは、あまりにも多くのトークンがシフトされて
 4846: 還元されないでいると、オーバーフローする可能性があります。
 4847: スタックがオーバーフローすると、オーバーフローを報告するために@code{yyerror}
 4848: を呼び出して、関数@code{yyparse}は0でない値を返します。
 4849: 
 4850: @vindex YYMAXDEPTH
 4851: マクロ@code{YYMAXDEPTH}を定義して、スタックオーバーフローが起こらないように、
 4852: 構文解析器のスタックの深さを調節できます。
 4853: マクロの値として、整数値を定義してください。
 4854: この値は、オーバーフローする前に、シフトされたが還元されていないトークンの
 4855: 最大数になります。
 4856: マクロの値として、コンパイル時に決定可能な定数式を指定してください。
 4857: 
 4858: 指定されたスタック領域は、割り当てられる必要はありません。
 4859: 大きな@code{YYMAXDEPTH}を指定すると、
 4860: 構文解析器はまず小さなスタック領域を割り当て、
 4861: 必要に応じてより大きなスタック領域を割り当てます。
 4862: この割り当ての増加は、何も表示せずに、自動的に行われます。
 4863: したがって、スタックをあまり必要としない通常の入力に対して
 4864: メモリを節約するために、@code{YYMAXDEPTH}を小さくする必要はありません。
 4865: 
 4866: @cindex default stack limit
 4867: @cindex 省略時のスタックの限界
 4868: @cindex スタックの限界, 省略時
 4869: 特に指定しないと、@code{YYMAXDEPTH}の値は10000になります。
 4870: 
 4871: @vindex YYINITDEPTH
 4872: マクロ@code{YYINIDEPTH}を指定して、最初に割り当てられるスタックの量を
 4873: 調節できます。この値は、コンパイル時に決定可能な整定数の必要があります。
 4874: 特に指定しないと、200になります。
 4875: 
 4876: 
 4877: @node Error Recovery, Context Dependency, Algorithm, Top
 4878: @chapter エラーからの回復
 4879: @cindex error recovery
 4880: @cindex recovery from errors
 4881: @cindex エラーからの回復
 4882: @cindex 回復
 4883: 
 4884: 構文解析エラーが起きた場合に、構文解析プログラムが止まることは、
 4885: 通常望ましくありません。
 4886: たとえば、コンパイラは入力の残りを構文解析して他のエラーを探せるように
 4887: エラーから回復するべきですし、電卓は次の式を受け入れるべきです。
 4888: 
 4889: 入力を1行ごとに処理する単純な対話的構文解析器は、
 4890: エラーが発生した場合に@code{yyparse}が1を返し、
 4891: 入力行の残りを無視し、
 4892: @code{yyparse}をもう一度呼び出してもかまいません。
 4893: しかし、コンパイラでこのように処理すると、
 4894: エラーに先立つ文法的文脈を忘れてしまうので不都合です。
 4895: 深い関数呼び出しの中で構文エラーが発生した場合に、
 4896: コンパイラがエラーに続く行をソースファイルの先頭のように
 4897: 扱うべきではありません。
 4898: 
 4899: @findex error
 4900: 特別なトークン@code{error}を認識するような規則を書くことによって、
 4901: 構文エラーから回復する方法を定義できます。
 4902: @code{error}は定義済みの終端記号で、自分で宣言する必要はなく、
 4903: エラー処理のために予約されています。
 4904: Bison構文解析器は、構文エラーが起こるたびに、@code{error}トークンを生成します。
 4905: 現在の文脈で@code{error}トークンを認識できる規則を書いていれば、
 4906: 構文解析を継続できます。
 4907: 
 4908: 例を示します。
 4909: 
 4910: @example
 4911: stmnts:  /* 空文字列 */
 4912:         | stmnts '\n'
 4913:         | stmnts exp '\n'
 4914:         | stmnts error '\n'
 4915: @end example
 4916: 
 4917: 第4の規則は、@code{error}とそれに続く改行が、任意の@code{stmnts}に
 4918: 続くことを認めます。
 4919: 
 4920: @code{exp}の中で構文エラーが発生するとどうなるでしょうか。
 4921: エラー回復規則は、厳密に解釈され、@code{stmnts}、@code{error}、改行からなる
 4922: 列に適用されます。
 4923: @code{exp}の中で構文エラーが起きると、おそらく、いくつかの余分なトークンまたは
 4924: 部分式がスタック上の最後の@code{stmnts}の後に存在し、
 4925: したがって、次の改行を読む前に読むべきトークンが存在するでしょう。
 4926: したがって、この通常の方法では規則を適用できません。
 4927: 
 4928: しかし、意味文脈と入力の一部を捨てることによって、
 4929: Bisonは強制的にこの場合に規則を適用できます。
 4930: まず、@code{error}トークンが受理可能な状態に戻るまで、
 4931: 状態とオブジェクトがスタックから捨てられます
 4932: (これは、すでに構文解析された部分式が捨てられ、
 4933: 最後の完全な@code{stmnts}に状態が戻ることを意味します)。
 4934: この時点で、@code{error}トークンがシフトされます。
 4935: そして、古い先読みトークンのシフトは受理不可能なので、
 4936: 受理可能なトークンを見つけるまで、
 4937: 構文解析器はトークンを読んで捨てます。
 4938: 前述の例では、次の改行がくるまで入力が読み捨てられ、
 4939: したがって、第4の規則が適用可能になります。
 4940: 
 4941: 文法中のエラー規則の選択は、エラー回復の戦略の選択です。
 4942: 単純で便利な戦略の1つは、エラーを検出したら、
 4943: 単純に現在の入力行または文を読み飛ばすことです。
 4944: 
 4945: @example
 4946: stmnt: error ';'  /* エラーがあれば、「;」がくるまで読み飛ばす。 */
 4947: @end example
 4948: 
 4949: すでに構文解析された開き区切りトークン
 4950: @c @footnote{【訳注】C言語での@samp{([@{}、
 4951: @c Pascal言語での@samp{begin}など。}
 4952: を、閉じ区切りトークンに対応させることは、
 4953: エラー処理のうまい方法です。そうしなければ、閉じ区切りトークンが
 4954: 後で不適切に現れて、別の重大なエラーを引き起こすでしょう。
 4955: 
 4956: @example
 4957: primary:  '(' expr ')'
 4958:         | '(' error ')'
 4959:         @dots{}
 4960:         ;
 4961: @end example
 4962: 
 4963: エラー回復の戦略は熟慮されるべきです。
 4964: 戦略が悪いと、1つの構文エラーがしばしば別のエラーを引き起こします。
 4965: 前述の例では、エラー回復規則は、1個の@code{stmnt}の中で起きると
 4966: 仮定されています。
 4967: そうでない可能性として、有効な@code{stmnt}の中に誤ってセミコロンが
 4968: まぎれ込んでいることを考えてみましょう。
 4969: エラー回復規則が最初のエラーを回復した後で、まぎれ込んだセミコロンに続く
 4970: 入力も無効な@code{stmnt}なので、もう1つの構文エラーがただちにみつかります。
 4971: 
 4972: エラー報告の洪水を避けるために、
 4973: 最初の構文エラーが起きた直後の他の構文エラーに対しては、
 4974: 構文解析器はエラー報告を表示しないべきでしょう。
 4975: 3個の連続する入力トークンのシフトに成功してから、
 4976: エラー報告を再開するべきです。
 4977: 
 4978: @code{error}トークンを受け付ける規則も、他の規則と同様に
 4979: アクションを持てることに注意してください。
 4980: 
 4981: @findex yyerrok
 4982: アクションの中でマクロ@code{yyerrok}を使って、
 4983: ただちにエラー報告を再開できます。
 4984: もし、エラー規則のアクションの中でこのマクロを使えば、
 4985: エラー報告は抑制されません。
 4986: このマクロに引数は不要で、@samp{yyerrok;}は有効なCの文です。
 4987: 
 4988: @findex yyclearin
 4989: 直前の先読みトークンは、エラーの直後に再解析されます。
 4990: これが不都合ならば、マクロ@code{yyclearin}によって先読みトークンを
 4991: 消してください。すなわち、エラー規則のアクションに
 4992: @samp{yyclearin;}文を書いてください。
 4993: 
 4994: たとえば、構文エラーにおいて、構文解析を再開すべき場所まで入力を進めるような、
 4995: エラー処理手続きを考えてみましょう。
 4996: 字句解析器から返される次の記号は、おそらく正しいでしょう。
 4997: 以前の先読みトークンは@samp{yyclearin;}によって捨てられるべきです。
 4998: 
 4999: @vindex YYRECOVERING
 5000: マクロ@code{YYRECOVERING}は、式を表し、構文解析器がエラーから回復する
 5001: 途中にあるならば値が1になり、通常の状態ならば値が0になります。
 5002: 値が1であるということは、新たな構文エラーに対するエラーの報告が、
 5003: 現在は抑制されていることを示します。
 5004: 
 5005: 
 5006: @node Context Dependency, Debugging, Error Recovery, Top
 5007: @chapter 文脈依存性の処理
 5008: 
 5009: Bisonの枠組みは、まずトークンを読み、
 5010: 次にトークンをより大きな文法的単位にグループ化することです。
 5011: 多くの言語では、トークンの意味は文脈の影響を受けます。
 5012: 文脈依存性によってBisonの枠組みが壊れますが、
 5013: (@dfn{kludges}として知られる)いくつかの技術を使って、
 5014: このような言語に対するBison構文解析器を書けます。
 5015: 
 5016: @menu
 5017: * Semantic Tokens::   トークン構文解析は意味的文脈に依存する.
 5018: * Lexical Tie-ins::   トークン構文解析は構文的文脈に依存する.
 5019: * Tie-in Recovery::   字句結び付きはエラー回復規則を書く方法に影響する.
 5020: @end menu
 5021: 
 5022: (実際に、「kludge」は、仕事を可能にしますが、
 5023: 美しくも頑丈でもない技術を意味します)
 5024: 
 5025: 
 5026: @node Semantic Tokens, Lexical Tie-ins,  , Context Dependency
 5027: @section トークン型の意味情報
 5028: 
 5029: C言語は文脈依存性をもっています。
 5030: すなわち、識別子の使われ方は、それの現在の意味に依存します。
 5031: 次の例を考えてみてください。
 5032: 
 5033: @example
 5034: foo (x);
 5035: @end example
 5036: 
 5037: これは、関数を呼び出す文のように見えます。
 5038: しかし、もし、@code{foo}が@code{typedef}された型名ならば、
 5039: この文は@code{x}の宣言になります。
 5040: C言語に対するBison構文解析器は、この入力を構文解析する方法を
 5041: どのように決定できるでしょうか。
 5042: 
 5043: GNU Cで使っている方法は、@code{IDENTIFIER}と@code{TYPENAME}という、
 5044: 2種類の異なるトークン型を使うことです。
 5045: @code{yylex}が識別子を見つけると、どちらのトークン型を返すか決めるために、
 5046: 識別子の現在の宣言を検索し、@code{typedef}として宣言されていれば
 5047: @code{TYPENAME}を返し、そうでなければ@code{IDENTIFIER}を返します。
 5048: 
 5049: そして、認識するトークン型を選ぶことによって、
 5050: 文法規則は文脈依存性を表現できます。
 5051: @code{IDENTIFIER}は、式として受け入れられますが、
 5052: @code{TYPENAME}は受け入れられません。
 5053: @code{TYPENAME}は、宣言の始まりとして受け入れられますが、
 5054: @code{IDENTIFIER}は受け入れられません。
 5055: 識別子の意味の区別が@emph{必要のない}文脈、
 5056: たとえば@code{typedef}名を隠す宣言の中では、
 5057: @code{TYPENAME}と@code{IDENTIFIER}の両方が受け入れられます。
 5058: すなわち、2個のトークン型に対してそれぞれ1個の規則を書くことが可能です。
 5059: 
 5060: この方法は、どの種類の識別子が許されるかの判断が、
 5061: その識別子が構文解析される場所の近くで行われるならば、
 5062: 単純に使えます。
 5063: しかし、C言語で、いつもそうであるとは限りません。
 5064: 次の例のように、以前に指定された明示的な型に規定された@code{typedef}名の
 5065: 再宣言が許されているからです。
 5066: 
 5067: @example
 5068: typedef int foo, bar, lose;
 5069: static foo (bar);        /* @r{@code{bar}を静的変数として再宣言する。} */
 5070: static int foo (lose);   /* @r{@code{foo}を関数として再宣言する。} */
 5071: @end example
 5072: 
 5073: 不幸にも、込み入った文法構造「宣言子(declarator)」によって、
 5074: 宣言された名前は、その宣言の構造自身から切り離されます。
 5075: 
 5076: 結果として、C言語に対するBison構文解析器は、
 5077: すべての非終端記号の名前を変えて、二重化されました。
 5078: 第1は、@code{typedef}名が再定義されているかもしれない宣言を構文解析し、
 5079: 第2は、再定義が起こりえない宣言を構文解析します。
 5080: 二重化したものの一部分を、簡単にするためにアクションを省略して、示します。
 5081: 
 5082: @example
 5083: initdcl:
 5084:           declarator maybeasm '='
 5085:           init
 5086:         | declarator maybeasm
 5087:         ;
 5088: 
 5089: notype_initdcl:
 5090:           notype_declarator maybeasm '='
 5091:           init
 5092:         | notype_declarator maybeasm
 5093:         ;
 5094: @end example
 5095: 
 5096: ここで、@code{initdcl}は@code{typedef}名を再宣言できますが、
 5097: @code{notype_initdcl}は再宣言できません。
 5098: @code{declarator}と@code{notype_declarator}の違いも同様です。
 5099: 
 5100: 前述の技術と、後述の字句解析結び付きには、
 5101: 字句解析に影響する情報が入力の別の部分を構文解析しているときに
 5102: 変化させられるという、共通点があります。
 5103: 前者では、情報が広域的で、プログラム@footnote{【訳注】構文解析器。}の別の目的に
 5104: 使われることが異なります。
 5105: 本当の字句解析結び付きは、文脈によって制御される、
 5106: 特別の目的のフラグを持ちます。
 5107: 
 5108: 
 5109: @node Lexical Tie-ins, Tie-in Recovery, Semantic Tokens, Context Dependency
 5110: @section 字句解析結び付き
 5111: @cindex lexical tie-in
 5112: @cindex 字句解析結び付き
 5113: 
 5114: 文脈依存性を処理する1つの方法は、@dfn{字句解析結び付き(lexical tie-in)}で、
 5115: Bisonのアクションによって設定されるフラグが、
 5116: トークンが構文解析される方法に影響します。
 5117: 
 5118: たとえば、C言語によく似ていて、@samp{hex (@var{hex-expr})}という
 5119: 特別な構造を持つ言語について、考えてみましょう。
 5120: 予約語@code{hex}がきた後にかっこで囲まれた式が続いて、
 5121: そのかっこの中ではすべての整数が16進数になります。
 5122: 特に、トークン@samp{a1b}は、このような文脈に現れれば、
 5123: 識別子ではなく整数として扱われる必要があります。
 5124: どのようにすればよいかを示します。
 5125: 
 5126: @example
 5127: @group
 5128: %@{
 5129: int hexflag;
 5130: %@}
 5131: %%
 5132: @dots{}
 5133: @end group
 5134: @group
 5135: expr:   IDENTIFIER
 5136:         | constant
 5137:         | HEX '('
 5138:                 @{ hexflag = 1; @}
 5139:           expr ')'
 5140:                 @{ hexflag = 0;
 5141:                    $$ = $4; @}
 5142:         | expr '+' expr
 5143:                 @{ $$ = make_sum ($1, $3); @}
 5144:         @dots{}
 5145:         ;
 5146: @end group
 5147: 
 5148: @group
 5149: constant:
 5150:           INTEGER
 5151:         | STRING
 5152:         ;
 5153: @end group
 5154: @end example
 5155: 
 5156: @code{yylex}は、@code{hexflag}の値が0でなければ、
 5157: すべての整数が16進数であると字句解析し、
 5158: 英字で始まるトークンも可能な限り整数と解釈すると、仮定します。
 5159: 
 5160: @code{hexflag}の宣言は、アクションから参照可能なように、
 5161: 文法ファイルのC宣言部に書かれる必要があります
 5162: (@pxref{C Declarations, ,The C Declarations Section})。
 5163: 同様に、@code{yylex}のプログラムにも、@code{hexflag}の宣言が必要です。
 5164: 
 5165: 
 5166: @node Tie-in Recovery,  , Lexical Tie-ins, Context Dependency
 5167: @section 字句解析結び付きとエラー回復
 5168: 
 5169: 字句解析結び付きは、厳密なエラー回復規則を要求します。
 5170: @xref{Error Recovery}。
 5171: 
 5172: その理由は、エラー回復規則の目的が、ある構成物の構文解析を中断し、
 5173: より大きな構成物の構文解析を再開することです。
 5174: 前述のC言語に似ている言語の例では、次のように、
 5175: 標準的なエラー回復規則は、次のセミコロンまでトークンを読み捨て、
 5176: 新しい文の構文解析を再開します。
 5177: 
 5178: @example
 5179: stmt:   expr ';'
 5180:         | IF '(' expr ')' stmt @{ @dots{} @}
 5181:         @dots{}
 5182:         error ';'
 5183:                 @{ hexflag = 0; @}
 5184:         ;
 5185: @end example
 5186: 
 5187: もし、@samp{hex (@var{expr})}の途中で構文エラーが発生すれば、
 5188: このエラー回復規則が適用され、完了した@samp{hex @var{expr})}に対する
 5189: アクションは決して実行されません。
 5190: すると、@code{hexflag}は、入力の残りの間ずっと設定されたままでいるか、
 5191: 次の@code{hex}予約語の出現までそのままの状態でいて、
 5192: 識別子が16進整数と誤解されます。
 5193: 
 5194: この問題を防ぐためには、エラー回復規則が
 5195: @code{hexflag}を元に戻すべきです。
 5196: 
 5197: さらに、式の内部で働くエラー回復規則があるかもしれません。
 5198: たとえば、次の例のように、かっこの中でエラーが発生すると、
 5199: 閉じかっこまで読み捨てるようなエラー回復規則が考えられます。
 5200: 
 5201: @example
 5202: @group
 5203: expr:   @dots{}
 5204:         | '(' expr ')'
 5205:                 @{ $$ = $2; @}
 5206:         | '(' error ')'
 5207:         @dots{}
 5208: @end group
 5209: @end example
 5210: 
 5211: もし、この規則が@code{hex}構造の中で働くならば、
 5212: その構造の中の内側のかっこに適用されるので、
 5213: 構造を中断するべきではありません。
 5214: したがって、このアクションではフラグを戻すべきではなく、
 5215: @code{hex}構造の残りはフラグを有効にしたまま構文解析されるべきです。
 5216: 
 5217: 状況に応じて、@code{hex}構造を中断できるかもしれないし、そうでないかもしれない
 5218: エラー回復規則があれば、どうなるでしょうか。
 5219: @code{hex}構造を中断すべきかどうか決定できるアクションを書けません。
 5220: そこで、もし、字句解析結び付きを使っているならば、
 5221: あなたが書いたエラー回復規則がそのようになっていないことを確かめるべきです。
 5222: それぞれの規則は、常にフラグを戻すべきか、あるいは常にフラグを戻さないべきか、
 5223: 決定できるべきです。
 5224: 
 5225: 
 5226: @node Debugging, Invocation, Context Dependency, Top
 5227: @chapter 構文解析器のデバッグ
 5228: @findex YYDEBUG
 5229: @findex yydebug
 5230: @cindex debugging
 5231: @cindex tracing the parser
 5232: @cindex 追跡, 構文解析器
 5233: @cindex 構文解析器の追跡
 5234: 
 5235: もし、Bison文法ファイルが正しくコンパイルされたのに、
 5236: 生成された構文解析器が思いどおりに動かない場合には、
 5237: @code{yydebug}構文解析器追跡機能が、調査の役に立つでしょう。
 5238: 
 5239: 追跡機能のコンパイルを有効にするためには、
 5240: 構文解析器をコンパイルするときに、マクロ@code{YYDEBUG}を定義する必要があります。
 5241: そのためには、コンパイラのオプションに@samp{-DYYDEBUG=1}を指定するか、
 5242: あるいは、文法ファイルのC宣言部に@samp{#define YYDEBUG 1}と書いておく
 5243: 必要があります(@pxref{C Declarations, ,The C Declarations Section})。
 5244: あるいは、Bisonを実行するときに(@pxref{Invocation, ,Invoking Bison})、
 5245: @samp{-t}オプションを指定しておくと、
 5246: @code{YYDEBUG}が定義され、追跡が可能になります。
 5247: 
 5248: 追跡機能は@code{stderr}を使うので、C宣言部に
 5249: @w{@code{#include <stdio.h>}}と書いておく必要があります。
 5250: 
 5251: 追跡機能付で構文解析器をコンパイルしたら、構文解析器の実行時に、
 5252: 追跡機能を有効にするために、@code{yydebug}変数を0でない値にしてください。
 5253: C言語のプログラム(おそらく@code{main}関数の中)でこの変数に代入するか、
 5254: あるいは、デバッガでこの変数の値を変えればいいでしょう。
 5255: 
 5256: @code{yydebug}が0でない場合、構文解析器はそれぞれの段階で、
 5257: 1行まはた2行の追跡情報を生成し、@code{stderr}に出力します。
 5258: 追跡情報には、次のような情報が含まれています。
 5259: 
 5260: @itemize @bullet
 5261: @item
 5262: 構文解析器が@code{yylex}を呼ぶたびに、
 5263: 読み込まれたトークンの種類が記録されます。
 5264: 
 5265: @item
 5266: トークンがシフトされるたびに、状態スタックの深さと完全な内容が
 5267: 表示されます(@pxref{Parser States})。
 5268: 
 5269: @item
 5270: 規則が還元されるたびに、どの規則が使われるか、そして、
 5271: 還元後の状態スタックの完全な内容が記録されます。
 5272: 
 5273: @end itemize
 5274: 
 5275: この情報を理解するためには、Bisonに@samp{-v}オプション
 5276: (@pxref{Invocation, ,Invoking Bison})を付けて実行すると生成される
 5277: 明細ファイルが参考になるでしょう。
 5278: このファイルには、さまざまな規則の中での位置による表現で
 5279: 各状態の意味が示され、また、
 5280: 各状態がそれぞれの可能な入力トークンによって
 5281: どのように動作するかが示されています。
 5282: 連続する追跡の意味を読むことによって、
 5283: 明細ファイルで仕様が示されている構文解析器の機能について、理解できるでしょう。
 5284: 何か望ましくないことが起きている部分を確認すれば、
 5285: 文法ファイルのどこに問題があるかわかるでしょう。
 5286: 
 5287: 構文解析器ファイルはC言語のプログラムなので、
 5288: Cのデバッガを使えますが、
 5289: 何が起きているか調べることは困難です。
 5290: 構文解析器関数は、有限状態機械インタープリタで、
 5291: アクションが実行されると、
 5292: プログラムの同じ部分が何度も何度も実行されます。
 5293: 実用的なのは文法の中で変数の値を調べることだけでしょう。
 5294: 
 5295: @findex YYPRINT
 5296: デバッグ情報には、通常、それぞれのトークンのトークン型だけが含まれ、
 5297: トークンの意味値は含まれません。
 5298: マクロ@code{YYPRINT}を定義することで、
 5299: トークンの意味値を表示させられます。
 5300: @code{YYPRINT}の定義には、3個の引数がともないます。
 5301: 構文解析器は、@code{YYPRINT}に、標準入出力ストリーム、
 5302: トークン型の数値番号、トークンの値(@code{yylval}による)を渡します。
 5303: 
 5304: 多機能電卓に適する@code{YYPRINT}の例を示します
 5305: (@pxref{Mfcalc Decl, ,Declarations for @code{mfcalc}})。
 5306: 
 5307: @smallexample
 5308: #define YYPRINT(file, type, value)   yyprint (file, type, value)
 5309: 
 5310: static void
 5311: yyprint (file, type, value)
 5312:      FILE *file;
 5313:      int type;
 5314:      YYSTYPE value;
 5315: @{
 5316:   if (type == VAR)
 5317:     fprintf (file, " %s", value.tptr->name);
 5318:   else if (type == NUM)
 5319:     fprintf (file, " %d", value.val);
 5320: @}
 5321: @end smallexample
 5322: 
 5323: 
 5324: @node Invocation, Table of Symbols, Debugging, Top
 5325: @chapter Bisonの実行
 5326: @cindex invoking Bison
 5327: @cindex Bison invocation
 5328: @cindex options for invoking Bison
 5329: @cindex Bisonの実行
 5330: @cindex 実行, Bison
 5331: @cindex Bison実行のオプション
 5332: @cindex オプション, Bison実行
 5333: 
 5334: 通常、Bisonは次のように実行します。
 5335: 
 5336: @example
 5337: bison @var{infile}
 5338: @end example
 5339: 
 5340: ここで、@var{infile}は文法ファイルで、名前が通常@samp{.y}で終わります。
 5341: 生成される構文解析器ファイルは、文法ファイルの名前の@samp{.y}を
 5342: @samp{.tab.c}に変えたものです。
 5343: したがって、@samp{bison foo.y}によって@samp{foo.tab.c}を得られますし、
 5344: @samp{bison hack/foo.y}によって@samp{hack/foo.tab.c}を得られます。
 5345: 
 5346: @menu
 5347: * Bison Options::     全てのオプションが詳しく、短いオプションでアルファ
 5348:                         ベット順に説明されている.
 5349: * Option Cross Key::  長いオプションのアルファッベット順のリスト.
 5350: * VMS Invocation::    VMSでのBisonのコマンド構文.
 5351: @end menu
 5352: 
 5353: 
 5354: @node Bison Options, Option Cross Key,  , Invocation
 5355: @section Bisonのオプション
 5356: 
 5357: Bisonは、伝統的な1文字のオプションと、記憶しやすい長いオプション名の
 5358: 両方を受け付けます。長いオプション名は、@samp{-}の代わりに、
 5359: @samp{--}で指定します。
 5360: 一意性を失わない範囲で、長いオプション名を省略できます。
 5361: 長いオプションが引数をともなう場合、たとえば、@samp{--file-prefix}では、
 5362: オプション名と引数の間に@samp{=}を入れます。
 5363: 
 5364: Bisonに対して指定可能なオプションの一覧を、アルファベット順に示します。
 5365: さらに、長い名前のアルファベット順の対応を示します。
 5366: 
 5367: @table @samp
 5368: @item -b @var{file-prefix}
 5369: @itemx --file-prefix=@var{prefix}
 5370: Bisonが生成するすべてのファイルの名前の前半部分を指定します。
 5371: 入力される文法ファイルの名前が@file{@var{prefix}.y}であった場合と、
 5372: 同じ結果を得られます。
 5373: 
 5374: @item -d
 5375: @itemx --defines
 5376: 文法ファイル中で定義されたトークン型名に対するマクロ定義、
 5377: 意味値型@code{YYSTYPE}、いくつかの@code{extern}変数宣言を含む、
 5378: 追加の出力ファイルを生成します。
 5379: 
 5380: 生成される構文解析ファイルの名前が@file{@var{name}.c}ならば、
 5381: このファイルの名前は@file{@var{name}.h}になります。
 5382: 
 5383: @code{yylex}関数を独立なソースファイルの中で定義しているならば、
 5384: それはトークン型番号と変数@code{yylval}を必要とするので、
 5385: このファイルを@code{#include}する必要があります
 5386: @xref{Token Values, ,Semantic Values of Tokens}。
 5387: 
 5388: @item -l
 5389: @itemx --no-lines
 5390: 構文解析器ファイルの中に、@code{#line}プリプロセッサディレクティブを生成しません。
 5391: 通常、Bisonはこれを生成し、Cコンパイラとデバッガが、
 5392: 文法ファイルのどこでエラーが発生したかを見つけるために使います。
 5393: このオプションは、エラーと構文解析器の行番号を結び付け、
 5394: 構文解析器を独立なソースファイルとして扱います。
 5395: 
 5396: @item -n
 5397: @itemx --no-parser
 5398: 構文解析器にCのプログラムを含めず、表だけを生成します。
 5399: 構文解析器ファイルは、@code{#define}ディレクティブと
 5400: 静的変数の宣言のみからなります。
 5401: 
 5402: このオプションにより、@file{@var{filename}.act}という名前のファイルに、
 5403: 文法アクションに対するC言語のプログラムが書かれます。
 5404: その書式は、@code{switch}文に対応するブレースで囲まれたブロックです。
 5405: 
 5406: @item -o @var{outfile}
 5407: @itemx --output-file=@var{outfile}
 5408: 生成される構文解析器ファイルの名前を指定します。
 5409: 
 5410: 他の出力ファイルのファイル名の指定は
 5411: @samp{-v}と@samp{-d}オプションの項を参照してください。
 5412: 
 5413: @item -p @var{prefix}
 5414: @itemx --name-prefix=@var{prefix}
 5415: 構文解析器が使う外部名を@samp{yy}でなく@var{prefix}で始まるように変えます。
 5416: 影響を受ける名前は、
 5417: @code{yyparse}、@code{yylex}、@code{yyerror}、@code{yynerrs}、
 5418: @code{yylval}、@code{yychar}、@code{yydebug}です。
 5419: 
 5420: たとえば、@samp{-p c}オプションを指定すれば、
 5421: 名前は@code{cparse}、@code{clex}などになります。
 5422: 
 5423: @xref{Multiple Parsers, ,Multiple Parsers in the Same Program}。
 5424: 
 5425: @item -r
 5426: @itemx --raw
 5427: @code{%raw}が指定されたように振る舞います。
 5428: @xref{Decl Summary}。
 5429: 
 5430: @item -t
 5431: @itemx --debug
 5432: デバッグ機能がコンパイルされるように、
 5433: マクロ@code{YYDEBUG}の定義を構文解析器ファイルに入れます
 5434: @xref{Debugging, ,Debugging Your Parser}。
 5435: 
 5436: @item -v
 5437: @itemx --verbose
 5438: 構文解析器の状態についての詳細な説明と、
 5439: それらの状態でそれぞれの先読みトークンが現れると何が起きるか記述した、
 5440: 追加のファイルを生成します。
 5441: 
 5442: このファイルは、演算子の優先順位によって解決したものも解決しなかった
 5443: ものも含めて、衝突についての説明を含んでいます。
 5444: 
 5445: 生成されるファイルの名前は、構文解析器のファイルの名前から、
 5446: @samp{.tab.c}または@samp{.c}を取り除いて、
 5447: 代わりに@samp{.output}を付けたものです。
 5448: 
 5449: したがって、入力の文法ファイルの名前が@file{foo.y}ならば、
 5450: 特に指定しないと、構文解析器ファイルの名前は@file{foo.tab.c}になり、
 5451: 詳細な説明のファイルの名前は@file{foo.output}になります。
 5452: 
 5453: @item -V
 5454: @itemx --version
 5455: バージョン番号を表示して、Bisonを終了させます。
 5456: 
 5457: @item -h
 5458: @itemx --help
 5459: コマンドラインオプションの要約を表示して、Bisonを終了させます。
 5460: 
 5461: @need 1750
 5462: @item -y
 5463: @itemx --yacc
 5464: @itemx --fixed-output-files
 5465: @samp{-o y.tab.c}と等価です。構文解析器ファイルの名前は
 5466: @file{y.tab.c}になり、他の出力ファイルの名前は@file{y.output}と
 5467: @file{y.tab.h}になります。このオプションの目的は、
 5468: 出力ファイルの名前をYaccに合わせることです。
 5469: 次のシェルスクリプトは、Yaccの代用になります。
 5470: 
 5471: @example
 5472: bison -y $*
 5473: @end example
 5474: @end table
 5475: 
 5476: 
 5477: @node Option Cross Key, VMS Invocation, Bison Options, Invocation
 5478: @section オプション対応表
 5479: 
 5480: オプションを、長い名前のアルファベット順に一覧表記して、
 5481: 対応する1文字オプションを書きます。
 5482: 
 5483: @tex
 5484: \def\leaderfill{\leaders\hbox to 1em{\hss.\hss}\hfill}
 5485: 
 5486: {\tt
 5487: \line{ --debug \leaderfill -t}
 5488: \line{ --defines \leaderfill -d}
 5489: \line{ --file-prefix \leaderfill -b}
 5490: \line{ --fixed-output-files \leaderfill -y}
 5491: \line{ --help \leaderfill -h}
 5492: \line{ --name-prefix \leaderfill -p}
 5493: \line{ --no-lines \leaderfill -l}
 5494: \line{ --no-parser \leaderfill -n}
 5495: \line{ --output-file \leaderfill -o}
 5496: \line{ --raw \leaderfill -r}
 5497: \line{ --token-table \leaderfill -k}
 5498: \line{ --verbose \leaderfill -v}
 5499: \line{ --version \leaderfill -V}
 5500: \line{ --yacc \leaderfill -y}
 5501: }
 5502: @end tex
 5503: 
 5504: @ifinfo
 5505: @example
 5506: --debug                               -t
 5507: --defines                             -d
 5508: --file-prefix=@var{prefix}                  -b @var{file-prefix}
 5509: --fixed-output-files --yacc           -y
 5510: --help                                -h
 5511: --name-prefix=@var{prefix}                  -p @var{name-prefix}
 5512: --no-lines                            -l
 5513: --no-parser                           -n
 5514: --output-file=@var{outfile}                 -o @var{outfile}
 5515: --raw                                 -r			
 5516: --token-table                         -k
 5517: --verbose                             -v
 5518: --version                             -V
 5519: @end example
 5520: @end ifinfo
 5521: 
 5522: 
 5523: @node VMS Invocation,  , Option Cross Key, Invocation
 5524: @section VMS上での実行
 5525: @cindex invoking Bison under VMS
 5526: @cindex VMS
 5527: @cindex 実行, VMS上
 5528: 
 5529: VMS上のBisonのコマンドライン構文は、VMSの慣習に合わせて、
 5530: 他のシステム上のBisonのコマンドライン構文と異なっています。
 5531: 
 5532: VMSでは、すべてのBisonのオプションについて、
 5533: @samp{--}の代わりに@samp{/}に続く長い名前のオプションを書き、
 5534: オプション名中の@samp{-}を@samp{_}に変えます。
 5535: VMS上での実行例を示します。
 5536: 
 5537: @example
 5538: bison /debug/name_prefix=bar foo.y
 5539: @end example
 5540: 
 5541: これは、POSIX上での次のコマンドラインと等価です。
 5542: 
 5543: @example
 5544: bison --debug --name-prefix=bar foo.y
 5545: @end example
 5546: 
 5547: VMSファイルシステムでは、@file{foo.tab.c}のようなファイル名が許されないので、
 5548: 構文解析器の名前は、上記の例の場合には、@file{foo_tab.c}になります。
 5549: 
 5550: 
 5551: @node Table of Symbols, Glossary, Invocation, Top
 5552: @appendix Bisonの記号一覧
 5553: @cindex Bison symbols, table of
 5554: @cindex symbols in Bison, table of
 5555: @cindex 記号一覧, Bison
 5556: @cindex Bisonの記号一覧
 5557: 
 5558: @table @code
 5559: @item error
 5560: エラー回復のために予約されているトークン名です。
 5561: このトークンが文法規則の中で使われていると、Bison構文解析器は、
 5562: 構文エラーを認識し、プロセスの実行を中断しません。
 5563: 実質的には、エラーを含む文が、有効であると認識されます。
 5564: エラーが起きると、@code{error}トークンが現在の先読みトークンになります。
 5565: @code{error}に対応するアクションが実行されて、
 5566: 先読みトークンがエラーの原因になったトークンに戻されます。
 5567: @xref{Error Recovery}。
 5568: 
 5569: @item YYABORT
 5570: 回復不可能な構文エラーが発生した場合のためのマクロで、
 5571: 実行するとただちに@code{yyparse}が1を返します。
 5572: エラー報告関数@code{yyerror}は呼び出されません。
 5573: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 5574: 
 5575: @item YYACCEPT
 5576: 構文解析器が言語を完全に読み終えた場合のためのマクロで、
 5577: 実行するとただちに@code{yyparse}が0を返します。
 5578: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 5579: 
 5580: @item YYBACKUP
 5581: 構文解析器のスタックから1個の値を捨て、先読みトークンのふりをさせます。
 5582: @xref{Action Features, ,Special Features for Use in Actions}。
 5583: 
 5584: @item YYERROR
 5585: 構文エラーがちょうど検出された場合のためのマクロで、
 5586: @code{yyerror}を呼び、可能ならば通常のエラー回復処理
 5587: (@pxref{Error Recovery})を実行し、不可能ならば
 5588: @code{yyparse}が1を返します。
 5589: @xref{Error Recovery}。
 5590: 
 5591: @item YYERROR_VERBOSE
 5592: Bison宣言部で@code{#define}によってこのマクロを定義すると、
 5593: @code{yyerror}が呼ばれたときに表示されるエラー報告が詳しくなります。
 5594: 
 5595: @item YYINITDEPTH
 5596: 構文解析器スタックの最初の大きさを指定するマクロです。
 5597: @xref{Stack Overflow}。
 5598: 
 5599: @item YYLEX_PARAM
 5600: @code{yyparse}が@code{yylex}に渡すための、追加の引数または
 5601: 引数の並びを指定するためのマクロです。
 5602: @xref{Pure Calling,, Calling Conventions for Pure Parsers}。
 5603: 
 5604: @item YYLTYPE
 5605: @code{yyloc}のデータ型を示すマクロで、4個のメンバからなる構造体です。
 5606: @xref{Token Positions, ,Textual Positions of Tokens}。
 5607: 
 5608: @item yyltype
 5609: @code{YYLTYPE}の省略時の値です。
 5610: 
 5611: @item YYMAXDEPTH
 5612: 構文解析器のスタックの最大の大きさを指定するマクロです。
 5613: @xref{Stack Overflow}。
 5614: 
 5615: @item YYPARSE_PARAM
 5616: @code{yyparse}が受け取るべき引数の名前を指定するマクロです。
 5617: @xref{Pure Calling,, Calling Conventions for Pure Parsers}。
 5618: 
 5619: @item YYRECOVERING
 5620: 構文解析器が構文エラーから回復している途中かどうかを示す値のマクロです。
 5621: @xref{Action Features, ,Special Features for Use in Actions}。
 5622: 
 5623: @item YYSTYPE
 5624: 意味値のデータ型を指定するためのマクロで、省略すると@code{int}になります。
 5625: @xref{Value Type, ,Data Types of Semantic Values}。
 5626: 
 5627: @item yychar
 5628: 広域的な@code{int}型の変数で、現在の先読みトークンの番号を記憶しています
 5629: (再入可能な構文解析器では、この変数は@code{yyparse}に局所的です)。
 5630: エラー回復規則のアクションは、この変数の値を調べられます。
 5631: @xref{Action Features, ,Special Features for Use in Actions}。
 5632: 
 5633: @item yyclearin
 5634: エラー回復規則のアクションで使われるマクロです。
 5635: 直前の先読みトークンを消去します。
 5636: @xref{Error Recovery}。
 5637: 
 5638: @item yydebug
 5639: @code{int}型の広域変数で、初期値は0です。
 5640: @code{yydebug}の値が0でないと、構文解析器は、
 5641: 読み込んだ記号と構文解析器のアクションに関する情報を表示します。
 5642: @xref{Debugging, ,Debugging Your Parser}。
 5643: 
 5644: @item yyerrok
 5645: 構文エラーの後で、構文解析器をただちに通常の状態に戻すためのマクロです。
 5646: @xref{Error Recovery}。
 5647: 
 5648: @item yyerror
 5649: エラーが起きたときに@code{yyparse}から呼び出される、ユーザー定義関数です。
 5650: この関数は1個の引数を受け取り、その引数はエラーの報告を含む文字列への
 5651: ポインタです。
 5652: @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}。
 5653: 
 5654: @item yylex
 5655: ユーザー定義の字句解析関数で、次のトークンを得るために、
 5656: 引数なしで呼び出されます。
 5657: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 5658: 
 5659: @item yylval
 5660: トークンに関連する意味値を@code{yylex}が置くための広域変数です
 5661: (再入可能な構文解析器では、これは@code{yyparse}の局所変数で、
 5662: その番地が@code{yylex}に渡されます)。
 5663: @xref{Token Values, ,Semantic Values of Tokens}。
 5664: 
 5665: @item yylloc
 5666: トークンに関連する行番号と桁番号を@code{yylex}が置くための
 5667: 広域変数です(再入可能な構文解析器では、この変数は@code{yyparse}に
 5668: 局所的で、その番地が@code{yylex}に渡されます)。
 5669: 文法アクションで@samp{@@}機能を使わないならば、
 5670: この値を無視してかまいません。
 5671: @xref{Token Positions, ,Textual Positions of Tokens}。
 5672: 
 5673: @item yynerrs
 5674: 構文エラーが発生するたびにBisonが値を1増やす広域変数です
 5675: (再入可能な構文解析器では、この変数は@code{yyparse}に局所的です)。
 5676: @xref{Error Reporting, ,The Error Reporting Function @code{yyerror}}。
 5677: 
 5678: @item yyparse
 5679: Bisonによって生成される構文解析器関数で、
 5680: この関数を呼び出すことによって構文解析が始まります。
 5681: @xref{Parser Function, ,The Parser Function @code{yyparse}}。
 5682: 
 5683: @item %left
 5684: トークンに左結合性を与えるBison宣言です。
 5685: @xref{Precedence Decl, ,Operator Precedence}。
 5686: 
 5687: @item %no_lines
 5688: 構文解析器ファイルの中に@code{#line}ディレクティブを生成しないための
 5689: Bison宣言です。
 5690: @xref{Decl Summary}。
 5691: 
 5692: @item %nonassoc
 5693: トークンに非結合性を与えるためのBison宣言です。
 5694: @xref{Precedence Decl, ,Operator Precedence}。
 5695: 
 5696: @item %prec
 5697: 指定された規則に優先順位を与えるためのBison宣言です。
 5698: @xref{Contextual Precedence, ,Context-Dependent Precedence}。
 5699: 
 5700: @item %pure_parser
 5701: 再入可能な構文解析器を生成するためのBison宣言です。
 5702: @xref{Pure Decl, ,A Pure (Reentrant) Parser}。
 5703: 
 5704: @item %raw
 5705: 通常のYacc互換トークン番号の代わりに、
 5706: トークン表のBison内部トークン番号を使うための、Bison宣言です。
 5707: @xref{Decl Summary}。
 5708: 
 5709: @item %right
 5710: トークンに右結合性を与えるためのBison宣言です。
 5711: @xref{Precedence Decl, ,Operator Precedence}。
 5712: 
 5713: @item %start
 5714: 開始記号を指定するためのBison宣言です。
 5715: @xref{Start Decl, ,The Start-Symbol}。
 5716: 
 5717: @item %token
 5718: 優先順位を指定せずにトークンを宣言するためのBison宣言です。
 5719: @xref{Token Decl, ,Token Type Names}。
 5720: 
 5721: @item %token_table
 5722: 構文解析器ファイルの中でトークン名の表を挿入するためのBison宣言です。
 5723: @xref{Decl Summary}。
 5724: 
 5725: @item %type
 5726: 非終端記号を宣言するためのBison宣言です。
 5727: @xref{Type Decl, ,Nonterminal Symbols}。
 5728: 
 5729: @item %union
 5730: 意味値として可能ないくつかのデータ型を指定するためのBison宣言です。
 5731: @xref{Union Decl, ,The Collection of Value Types}.
 5732: @end table
 5733: 
 5734: Bison文法ファイルの中で使う、区切り記号があります。
 5735: 
 5736: @table @samp
 5737: @item %%
 5738: Bison宣言部、文法規則部、(省略可能な)Cプログラム部を区切る記号です。
 5739: @xref{Grammar Layout, ,The Overall Layout of a Bison Grammar}。
 5740: 
 5741: @item %@{ %@}
 5742: 文法ファイルの@samp{%@{}と@samp{%@}}の間に書かれたすべてのプログラムは、
 5743: そのまま構文解析器ファイルに複写されます。
 5744: このようなプログラムが、文法ファイルのC宣言部を構成します。
 5745: @xref{Grammar Outline, ,Outline of a Bison Grammar}。
 5746: 
 5747: @item /*@dots{}*/
 5748: C言語と同様のコメントです。
 5749: 
 5750: @item :
 5751: 規則の結果と構成要素を分離する記号です。
 5752: @xref{Rules, ,Syntax of Grammar Rules}。
 5753: 
 5754: @item ;
 5755: 規則の終わりの記号です。
 5756: @xref{Rules, ,Syntax of Grammar Rules}。
 5757: 
 5758: @item |
 5759: 同一の非終端記号を結果とする複数の規則を区切る記号です。
 5760: @xref{Rules, ,Syntax of Grammar Rules}。
 5761: @end table
 5762: 
 5763: 
 5764: @node Glossary, Index, Table of Symbols, Top
 5765: @appendix 用語集
 5766: @cindex glossary
 5767: @cindex 用語集
 5768: 
 5769: @table @asis
 5770: @item Backus-Naur Form(BNF)(バッカス-ナウア記法)
 5771: 文脈自由文法を形式的に表現する方法です。
 5772: BNFは、1963年の報告@cite{ALGOL-60}で初めて使われました。
 5773: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 5774: 
 5775: @item Context-free grammars(文脈自由文法)
 5776: 文脈に関係なく適用される規則によって定められる文法です。
 5777: したがって、もし、整数は式として使われてもよいという規則があれば、
 5778: 式が許される@emph{あらゆる場所で}整数の利用が許されます。
 5779: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 5780: 
 5781: @item Dynamic allocation(動的割り当て)
 5782: プログラムをコンパイルするときでも、関数の実行を始めるときでもなく、
 5783: 実行の途中でメモリを割り当てることです。
 5784: 
 5785: @item Empty string(空文字列)
 5786: 集合論での空集合と同様に、空文字列とは長さが0の文字列です。
 5787: 
 5788: @item Finite-state stack machine(有限状態スタック機械)
 5789: その完全な状態が、各瞬間での状態で記述される「機械」です。
 5790: 機械への入力が処理されると、機械の論理に応じて、
 5791: 機械の状態が別の状態に変わります。
 5792: 本書では、入力とは構文解析されている言語で、
 5793: 状態とは文法規則のさまざまな段階です。
 5794: @xref{Algorithm, ,The Bison Parser Algorithm }。
 5795: 
 5796: @item Grouping(グループ)
 5797: 言語の構成要素で、(一般的に)文法的に分割可能なのもです。
 5798: たとえば、C言語の「式」や「宣言」です。
 5799: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 5800: 
 5801: @item Infix operator(中間記法演算子)
 5802: 演算の対象となるオペランドの中間に置かれる算術演算子です。
 5803: 
 5804: @item Input stream(入力ストリーム)
 5805: 入出力装置またはプログラムの間での、連続的なデータの流れです。
 5806: 
 5807: @item Language construct(言語構文)
 5808: 言語の概要を示す典型的な方法の1つです。
 5809: たとえば、C言語の構文の1つは@code{if}文です。
 5810: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 5811: 
 5812: @item Left associativity(左結合性)
 5813: 左結合性を持つ演算子は、左から右に向かって構文解析されます。
 5814: たとえば、@samp{a+b+c}では、まず@samp{a+b}が計算され、
 5815: 次に@samp{c}との和が計算されます。
 5816: @xref{Precedence, ,Operator Precedence}。
 5817: 
 5818: @item Left recursion(左再帰)
 5819: 結果の記号が構成要素の最初の記号と等しいような規則です。
 5820: たとえば、@samp{expseq1 : expseq1 ',' exp;}が左再帰です。
 5821: @xref{Recursion, ,Recursive Rules}。
 5822: 
 5823: @item Left-to-right parsing(LR構文解析)
 5824: 左側から右側に向かって、トークンを次々に解析していくような、
 5825: 言語の構文解析方法です。
 5826: @xref{Algorithm, ,The Bison Parser Algorithm }。
 5827: 
 5828: @item Lexical analyzer(scanner)(字句解析器)
 5829: 入力ストリームを読んで、トークンを1つずつ返す関数です。
 5830: @xref{Lexical, ,The Lexical Analyzer Function @code{yylex}}。
 5831: 
 5832: @item Lexical tie-in(字句解析結び付き)
 5833: 文法規則によって設定されるフラグが、トークンが字句解析される方法に
 5834: 影響することです。
 5835: @xref{Lexical Tie-ins}。
 5836: 
 5837: @item Literal string token(リテラル文字列トークン)
 5838: 2文字以上の決まった文字列からなるトークンです。
 5839: @xref{Symbols}。
 5840: 
 5841: @item Look-ahead token(先読みトークン)
 5842: すでに読み込まれていて、シフトされていないトークンです。
 5843: @xref{Look-Ahead, ,Look-Ahead Tokens}。
 5844: 
 5845: @item LALR(1)
 5846: Bison(または似ているほとんどの構文解析器)によって扱える、
 5847: 文脈自由文法の一部分で、LR(1)の部分集合です。
 5848: @xref{Mystery Conflicts, ,Mysterious Reduce/Reduce Conflicts}。
 5849: 
 5850: @item LR(1)
 5851: 任意の入力のあいまいでない構文解析に対して、
 5852: 単に1個の先読みトークンを必要とするような、
 5853: 文脈自由文法の一部分です。
 5854: 
 5855: @item Nonterminal symbol(非終端記号)
 5856: 文法的構成要素を表す文法記号で、文法規則によってより小さな構成要素に
 5857: 分解できるものです。言い換えると、トークンでない構成要素です。
 5858: @xref{Symbols}。
 5859: 
 5860: @item Parse error(構文エラー)
 5861: 入力ストリームを構文解析しているときに、誤った文法によって発生するエラーです。
 5862: @xref{Error Recovery}。
 5863: 
 5864: @item Parser(構文解析器)
 5865: 字句解析器から渡されたトークンの集合の文法的構造を解析して、
 5866: 言語の有効な文を認識する関数です。
 5867: 
 5868: @item Postfix operator(後置演算子)
 5869: 演算の対象のオペランドの後に置かれる算術演算子です。
 5870: 
 5871: @item Reduction(還元)
 5872: 文法規則に従って、非終端記号または終端記号の列を、
 5873: 1個の非終端記号に置き換えることです。
 5874: @xref{Algorithm, ,The Bison Parser Algorithm }。
 5875: 
 5876: @item Reentrant(再入可能)
 5877: 再入可能な手続きとは、複数の呼び出しの間での相互作用なしに、
 5878: 並行して任意の数を呼び出せる手続きです。
 5879: @footnote{【訳注】ある関数が終了する前に、
 5880: その同じ関数を非同期に呼び出してもよいということ。}
 5881: @xref{Pure Decl, ,A Pure (Reentrant) Parser}。
 5882: 
 5883: @item Reverse polish notation(逆ポーランド記法)
 5884: すべての演算子が後置記法演算子であるような言語です。
 5885: 
 5886: @item Right recursion(右再帰)
 5887: 規則の結果の記号が、規則の最後の構成要素と同じ記号であるような規則です。
 5888: たとえば、@samp{expseq1: exp ',' expseq1;}は右再帰です。
 5889: @xref{Recursion, ,Recursive Rules}.
 5890: 
 5891: @item Semantics(意味)
 5892: 計算機言語では、言語の各インスタンスが起こすアクションによって、
 5893: 意味が指定されます。すなわち、各文の意味です。
 5894: @xref{Semantics, ,Defining Language Semantics}。
 5895: 
 5896: @item Shift(シフト)
 5897: 構文解析器がシフトするとは、
 5898: すでに認識されているある規則によってただちに還元する代わりに、
 5899: ストリームからのさらなる入力を分析することです。
 5900: @xref{Algorithm, ,The Bison Parser Algorithm }。
 5901: 
 5902: @item Single-character literal(1文字リテラル)
 5903: そのままに解釈される@footnote{【訳注】字句解析器によって}1文字です。
 5904: @xref{Grammar in Bison, ,From Formal Rules to Bison Input}。
 5905: 
 5906: @item Start symbol(開始記号)
 5907: 構文解析された有効な言語の全体を表す非終端記号です。
 5908: 通常、言語仕様に書かれた最初の非終端記号です。
 5909: @xref{Start Decl, ,The Start-Symbol}。
 5910: 
 5911: @item Symbol table(記号表)
 5912: 繰り返し使われる記号の情報を認識して使うために、
 5913: 構文解析の途中で、記号の名前と関連する情報を記憶するデータ構造です。
 5914: @xref{Multi-function Calc}。
 5915: 
 5916: @item Token(トークン)
 5917: 言語の、基本的で、文法的に分割できない単位です。
 5918: 文法の中のトークンを記述する記号を終端記号といいます。
 5919: Bison構文解析器の入力は、字句解析器からの、
 5920: トークンの流れです。
 5921: @xref{Symbols}。
 5922: 
 5923: @item Terminal symbol(終端記号)
 5924: 文法規則を持たず、したがって文法的に分割できない文法記号です。
 5925: これが表す文字の集まりをトークンといいます。
 5926: @xref{Language and Grammar, ,Languages and Context-Free Grammars}。
 5927: @ignore
 5928: この行を含む3行は info ファイル作成時のエラーを回避するために挿入(編集担当)
 5929: @end ignore
 5930: @end table
 5931: 
 5932: 
 5933: @node Index,  , Glossary, Top
 5934: @unnumbered 索引
 5935: 
 5936: @printindex cp
 5937: 
 5938: @contents
 5939: 
 5940: @bye
 5941: 
 5942: 
 5943: 
 5944: 
 5945: @c old menu
 5946: 
 5947: * Introduction::
 5948: * Conditions::
 5949: * Copying::           The GNU General Public License says
 5950:                         how you can copy and share Bison
 5951: 
 5952: Tutorial sections:
 5953: * Concepts::          Basic concepts for understanding Bison.
 5954: * Examples::          Three simple explained examples of using Bison.
 5955: 
 5956: Reference sections:
 5957: * Grammar File::      Writing Bison declarations and rules.
 5958: * Interface::         C-language interface to the parser function @code{yyparse}.
 5959: * Algorithm::         How the Bison parser works at run-time.
 5960: * Error Recovery::    Writing rules for error recovery.
 5961: * Context Dependency::What to do if your language syntax is too
 5962:                         messy for Bison to handle straightforwardly.
 5963: * Debugging::         Debugging Bison parsers that parse wrong.
 5964: * Invocation::        How to run Bison (to produce the parser source file).
 5965: * Table of Symbols::  All the keywords of the Bison language are explained.
 5966: * Glossary::          Basic concepts are explained.
 5967: * Index::             Cross-references to the text.
 5968: 
 5969: 
 5970: 

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