4 - Forth Interest Group

action is embedded in the production (like this: reduce :
f oo { misc . C verbiage ) bar), the action is triggered
when the token string leading up to it is seen. Notice that this
will cause a reducdreduce conflict if two rules have the same
viable prefut, even if the actions are identical. To get around
this, split the two productions into three, and perform the
action at the end of the production that is common to both
of the originals. If the actions required are not identical, you
either have to find some way to postpone the action to the
end of the production, or you will have to use some parser
generator besides yacc. For example, this:
£00: footokenl { foofunc(); 1 footoken2
I f ootokenl ( f oof unc ( ) ; ) f ootoken3
must be rewritten as:
fooprefix: footokenl { foofunc0; 1
£00: fooprefix footoken2
I fooprefix footoken3
and this:
£00: footokenl { foofuncl0; ) footoken2
I footokenl I foofunc2 0 ; ) footoken3
must be rewritten to move the action to the end of the
productions, or at least past the point where the productions
share a viable prefix.
Each token in yacc can have an associated value. This
value is set in the actions associated with productions for
nonterminals, or the lexical analyzer for terminals. It can be
accessed in a similar fashion to the arguments to macros in
m4, by $ (some digit) , where the digit corresponds to the
token in the production. The value is set by assigning a value
to $ $ in the action corresponding to the production. Thus, this:
expr: \-I expr %prec UMINUS { $$ = - $2; }
would set the value of the left-hand expr to minus the righthand
expr. The lexical analyzer can set a token value by
assigning global yylval' The type
of the values $$, $1, etc. Can either be Set by defining the
YY~TYPE to something, or by the command
%union in the declarations section. Since the FSAT project's
C-to-Forth compiler will need to operate on strings and an
associated type, I'll be using
the first method, kludged to
allow me to store both a string
and a type value. If neither
yys~yp~ is defied nor the
keyword %union is used, the
type will default to int.
Of course, we'd be in a
pretty sorry state if our compilers
couldn't handle syntax errors.
yacc does have a way to
easily integrate error handling,
however. It uses the psuedoterminalerror.
error stands
'
Figure Three.
%token INCLUDE /* #include token */
%token FILENAME
for any sequence of input that doesn't form a valid production
in the current context. For example, since a C statement must
end with a ';' character, h s production would recognize an
erroneous statement:
statement : error ' ; '
This works by getting tokens from the lexical analyzer
until the token or tokens following the psuedo-terminal
error are seen. These tokens are discarded. This is very
handy for resynchronizing the input stream after an error
condition. Although this won't correctly handle the case
described above, where the opening '