Return to ssa CVS log

Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ps1 / 15.yacc

Annotation of 43BSDReno/share/doc/ps1/15.yacc/ssa, revision 1.1.1.1

1.1       root        1: .\"    @(#)ssa 6.1 (Berkeley) 5/8/86
                      2: .\"
                      3: .SH
                      4: Appendix A:  A Simple Example
                      5: .PP
                      6: This example gives the complete Yacc specification for a small desk calculator;
                      7: the desk calculator has 26 registers, labeled ``a'' through ``z'', and accepts
                      8: arithmetic expressions made up of the operators +, \-, *, /,
                      9: % (mod operator), & (bitwise and), | (bitwise or), and assignment.
                     10: If an expression at the top level is an assignment, the value is not
                     11: printed; otherwise it is.
                     12: As in C, an integer that begins with 0 (zero) is assumed to be octal;
                     13: otherwise, it is assumed to be decimal.
                     14: .PP
                     15: As an example of a Yacc specification, the desk calculator
                     16: does a reasonable job of showing how precedences and ambiguities
                     17: are used, and demonstrating simple error recovery.
                     18: The major oversimplifications are that the
                     19: lexical analysis phase is much simpler than for most applications, and the
                     20: output is produced immediately, line by line.
                     21: Note the way that decimal and octal integers are read in by the grammar rules;
                     22: This job is probably better done by the lexical analyzer.
                     23: .sp
                     24: .nf
                     25: .ta .5i 1i 1.5i 2i 2.5i
                     26: 
                     27: %{
                     28: #  include  <stdio.h>
                     29: #  include  <ctype.h>
                     30: 
                     31: int  regs[26];
                     32: int  base;
                     33: 
                     34: %}
                     35: 
                     36: %start  list
                     37: 
                     38: %token  DIGIT  LETTER
                     39: 
                     40: %left  \'|\'
                     41: %left  \'&\'
                     42: %left  \'+\'  \'\-\'
                     43: %left  \'*\'  \'/\'  \'%\'
                     44: %left  UMINUS      /*  supplies  precedence  for  unary  minus  */
                     45: 
                     46: %%      /*  beginning  of  rules  section  */
                     47: 
                     48: list   :       /*  empty  */
                     49:        |       list  stat  \'\en\'
                     50:        |       list  error  \'\en\'
                     51:                        {       yyerrok;  }
                     52:        ;
                     53: 
                     54: stat   :       expr
                     55:                        {       printf( "%d\en", $1 );  }
                     56:        |       LETTER  \'=\'  expr
                     57:                        {       regs[$1]  =  $3;  }
                     58:        ;
                     59: 
                     60: expr   :       \'(\'  expr  \')\'
                     61:                        {       $$  =  $2;  }
                     62:        |       expr  \'+\'  expr
                     63:                        {       $$  =  $1  +  $3;  }
                     64:        |       expr  \'\-\'  expr
                     65:                        {       $$  =  $1  \-  $3;  }
                     66:        |       expr  \'*\'  expr
                     67:                        {       $$  =  $1  *  $3;  }
                     68:        |       expr  \'/\'  expr
                     69:                        {       $$  =  $1  /  $3;  }
                     70:        |       expr  \'%\'  expr
                     71:                        {       $$  =  $1  %  $3;  }
                     72:        |       expr  \'&\'  expr
                     73:                        {       $$  =  $1  &  $3;  }
                     74:        |       expr  \'|\'  expr
                     75:                        {       $$  =  $1  |  $3;  }
                     76:        |       \'\-\'  expr        %prec  UMINUS
                     77:                        {       $$  =  \-  $2;  }
                     78:        |       LETTER
                     79:                        {       $$  =  regs[$1];  }
                     80:        |       number          
                     81:        ;
                     82: 
                     83: number :       DIGIT
                     84:                        {       $$ = $1;    base  =  ($1==0)  ?  8  :  10;  }
                     85:        |       number  DIGIT
                     86:                        {       $$  =  base * $1  +  $2;  }
                     87:        ;
                     88: 
                     89: %%      /*  start  of  programs  */
                     90: 
                     91: yylex() {              /*  lexical  analysis  routine  */
                     92:               /*  returns  LETTER  for  a  lower  case  letter,  yylval = 0  through  25  */
                     93:               /*  return  DIGIT  for  a  digit,  yylval = 0  through  9  */
                     94:               /*  all  other  characters  are  returned  immediately  */
                     95: 
                     96:        int  c;
                     97: 
                     98:        while(  (c=getchar())  ==  \' \'  )  {  /*  skip  blanks  */  }
                     99: 
                    100:        /*  c  is  now  nonblank  */
                    101: 
                    102:        if(  islower(  c  )  )  {       
                    103:                yylval  =  c  \-  \'a\';
                    104:                return  (  LETTER  );
                    105:                }
                    106:        if(  isdigit(  c  )  )  {       
                    107:                yylval  =  c  \-  \'0\';
                    108:                return(  DIGIT  );
                    109:                }
                    110:        return(  c  );
                    111:        }
                    112: .fi
                    113: .bp

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.