bison_4.htm

Lex和Yacc的Manual

except their types.
</P>
<P>
The semantic value has all the rest of the information about the
meaning of the token, such as the value of an integer, or the name of an
identifier.  (A token such as <CODE>','</CODE> which is just punctuation doesn't
need to have any semantic value.)

</P>
<P>
For example, an input token might be classified as token type
<CODE>INTEGER</CODE> and have the semantic value 4.  Another input token might
have the same token type <CODE>INTEGER</CODE> but value 3989.  When a grammar
rule says that <CODE>INTEGER</CODE> is allowed, either of these tokens is
acceptable because each is an <CODE>INTEGER</CODE>.  When the parser accepts the
token, it keeps track of the token's semantic value.

</P>
<P>
Each grouping can also have a semantic value as well as its nonterminal
symbol.  For example, in a calculator, an expression typically has a
semantic value that is a number.  In a compiler for a programming
language, an expression typically has a semantic value that is a tree
structure describing the meaning of the expression.

</P>


<H2><A NAME="SEC11" HREF="index.html#SEC11">Semantic Actions</A></H2>
<P>
<A NAME="IDX16"></A>
<A NAME="IDX17"></A>

</P>
<P>
In order to be useful, a program must do more than parse input; it must
also produce some output based on the input.  In a Bison grammar, a grammar
rule can have an <STRONG>action</STRONG> made up of C statements.  Each time the
parser recognizes a match for that rule, the action is executed.
See section <A HREF="bison_6.html#SEC46">Actions</A>.
        
Most of the time, the purpose of an action is to compute the semantic value
of the whole construct from the semantic values of its parts.  For example,
suppose we have a rule which says an expression can be the sum of two
expressions.  When the parser recognizes such a sum, each of the
subexpressions has a semantic value which describes how it was built up.
The action for this rule should create a similar sort of value for the
newly recognized larger expression.

</P>
<P>
For example, here is a rule that says an expression can be the sum of
two subexpressions:

</P>

<PRE>
expr: expr '+' expr   { $$ = $1 + $3; }
        ;
</PRE>

<P>
The action says how to produce the semantic value of the sum expression
from the values of the two subexpressions.

</P>


<H2><A NAME="SEC12" HREF="index.html#SEC12">Bison Output: the Parser File</A></H2>
<P>
<A NAME="IDX18"></A>
<A NAME="IDX19"></A>
<A NAME="IDX20"></A>
<A NAME="IDX21"></A>

</P>
<P>
When you run Bison, you give it a Bison grammar file as input.  The output
is a C source file that parses the language described by the grammar.
This file is called a <STRONG>Bison parser</STRONG>.  Keep in mind that the Bison
utility and the Bison parser are two distinct programs: the Bison utility
is a program whose output is the Bison parser that becomes part of your
program.

</P>
<P>
The job of the Bison parser is to group tokens into groupings according to
the grammar rules--for example, to build identifiers and operators into
expressions.  As it does this, it runs the actions for the grammar rules it
uses.

</P>
<P>
The tokens come from a function called the <STRONG>lexical analyzer</STRONG> that you
must supply in some fashion (such as by writing it in C).  The Bison parser
calls the lexical analyzer each time it wants a new token.  It doesn't know
what is "inside" the tokens (though their semantic values may reflect
this).  Typically the lexical analyzer makes the tokens by parsing
characters of text, but Bison does not depend on this.  See section <A HREF="bison_7.html#SEC61">The Lexical Analyzer Function <CODE>yylex</CODE></A>.

</P>
<P>
The Bison parser file is C code which defines a function named
<CODE>yyparse</CODE> which implements that grammar.  This function does not make
a complete C program: you must supply some additional functions.  One is
the lexical analyzer.  Another is an error-reporting function which the
parser calls to report an error.  In addition, a complete C program must
start with a function called <CODE>main</CODE>; you have to provide this, and
arrange for it to call <CODE>yyparse</CODE> or the parser will never run.
See section <A HREF="bison_7.html#SEC59">Parser C-Language Interface</A>.

</P>
<P>
Aside from the token type names and the symbols in the actions you
write, all variable and function names used in the Bison parser file
begin with <SAMP>`yy'</SAMP> or <SAMP>`YY'</SAMP>.  This includes interface functions
such as the lexical analyzer function <CODE>yylex</CODE>, the error reporting
function <CODE>yyerror</CODE> and the parser function <CODE>yyparse</CODE> itself.
This also includes numerous identifiers used for internal purposes.
Therefore, you should avoid using C identifiers starting with <SAMP>`yy'</SAMP>
or <SAMP>`YY'</SAMP> in the Bison grammar file except for the ones defined in
this manual.

</P>


<H2><A NAME="SEC13" HREF="index.html#SEC13">Stages in Using Bison</A></H2>
<P>
<A NAME="IDX22"></A>
<A NAME="IDX23"></A>

</P>
<P>
The actual language-design process using Bison, from grammar specification
to a working compiler or interpreter, has these parts:

</P>

<OL>
<LI>

Formally specify the grammar in a form recognized by Bison
(see section <A HREF="bison_6.html#SEC34">Bison Grammar Files</A>).  For each grammatical rule in the language,
describe the action that is to be taken when an instance of that rule
is recognized.  The action is described by a sequence of C statements.

<LI>

Write a lexical analyzer to process input and pass tokens to the
parser.  The lexical analyzer may be written by hand in C
(see section <A HREF="bison_7.html#SEC61">The Lexical Analyzer Function <CODE>yylex</CODE></A>).  It could also be produced using Lex, but the use
of Lex is not discussed in this manual.

<LI>

Write a controlling function that calls the Bison-produced parser.

<LI>

Write error-reporting routines.
</OL>

<P>
To turn this source code as written into a runnable program, you
must follow these steps:

</P>

<OL>
<LI>

Run Bison on the grammar to produce the parser.

<LI>

Compile the code output by Bison, as well as any other source files.

<LI>

Link the object files to produce the finished product.
</OL>



<H2><A NAME="SEC14" HREF="index.html#SEC14">The Overall Layout of a Bison Grammar</A></H2>
<P>
<A NAME="IDX24"></A>
<A NAME="IDX25"></A>
<A NAME="IDX26"></A>
<A NAME="IDX27"></A>

</P>
<P>
The input file for the Bison utility is a <STRONG>Bison grammar file</STRONG>.  The
general form of a Bison grammar file is as follows:

</P>

<PRE>
%{
<VAR>C declarations</VAR>
%}

<VAR>Bison declarations</VAR>

%%
<VAR>Grammar rules</VAR>
%%
<VAR>Additional C code</VAR>
</PRE>

<P>
The <SAMP>`%%'</SAMP>, <SAMP>`%{'</SAMP> and <SAMP>`%}'</SAMP> are punctuation that appears
in every Bison grammar file to separate the sections.

</P>
<P>
The C declarations may define types and variables used in the actions.
You can also use preprocessor commands to define macros used there, and use
<CODE>#include</CODE> to include header files that do any of these things.

</P>
<P>
The Bison declarations declare the names of the terminal and nonterminal
symbols, and may also describe operator precedence and the data types of
semantic values of various symbols.

</P>
<P>
The grammar rules define how to construct each nonterminal symbol from its
parts.

</P>
<P>
The additional C code can contain any C code you want to use.  Often the
definition of the lexical analyzer <CODE>yylex</CODE> goes here, plus subroutines
called by the actions in the grammar rules.  In a simple program, all the
rest of the program can go here.

</P>
<HR>
Go to the <A HREF="bison_1.html">first</A>, <A HREF="bison_3.html">previous</A>, <A HREF="bison_5.html">next</A>, <A HREF="bison_15.html">last</A> section, <A HREF="index.html">table of contents</A>.
</BODY>
</HTML>