Return to parse.y CVS log

Up to [CSRG BSD Unix] / 42BSD / etc / htable

Annotation of 42BSD/etc/htable/parse.y, revision 1.1.1.1

1.1       root        1: %{
                      2: #ifndef lint
                      3: static char sccsid[] = "@(#)parse.y    4.2 (Berkeley) 10/21/82";
                      4: #endif
                      5: 
                      6: #include "htable.h"
                      7: %}
                      8: 
                      9: %union {
                     10:        int     number;
                     11:        struct  addr *addrlist;
                     12:        struct  name *namelist;
                     13: }
                     14: %start Table
                     15: 
                     16: %token                 END
                     17: %token <number>                NUMBER KEYWORD
                     18: %token <namelist>      NAME
                     19: 
                     20: %type <namelist>       Names Cputype Opsys Protos Proto
                     21: %type <addrlist>       Addresses Address
                     22: %%
                     23: Table  :       Entry
                     24:        |       Table Entry
                     25:        ;
                     26: 
                     27: Entry  :       KEYWORD ':' Addresses ':' Names ':' END
                     28:        = {
                     29:                do_entry($1, $3, $5, NONAME, NONAME, NONAME);
                     30:        }
                     31:        |       KEYWORD ':' Addresses ':' Names ':' Cputype ':' END
                     32:        = {
                     33:                do_entry($1, $3, $5, $7, NONAME, NONAME);
                     34:        }
                     35:        |       KEYWORD ':' Addresses ':' Names ':' Cputype ':' Opsys ':' END
                     36:        = {
                     37:                do_entry($1, $3, $5, $7, $9, NONAME);
                     38:        }
                     39:        |       KEYWORD ':' Addresses ':' Names ':' Cputype ':' Opsys ':' ':' END
                     40:        = {
                     41:                do_entry($1, $3, $5, $7, $9, NONAME);
                     42:        }
                     43:        |       KEYWORD ':' Addresses ':' Names ':' Cputype ':' Opsys ':' Protos ':' END
                     44:        = {
                     45:                do_entry($1, $3, $5, $7, $9, $11);
                     46:        }
                     47:        |       error END
                     48:        |       END             /* blank line */
                     49:        ;
                     50: 
                     51: Addresses:     Address
                     52:        = {
                     53:                $$ = $1;
                     54:        }
                     55:        |       Address ',' Addresses
                     56:        = {
                     57:                $1->addr_link = $3;
                     58:                $$ = $1;
                     59:        }
                     60:        ;
                     61: 
                     62: Address        :       NUMBER '.' NUMBER '.' NUMBER '.' NUMBER
                     63:        = {
                     64:                char *a;
                     65: 
                     66:                $$ = (struct addr *)malloc(sizeof (struct addr));
                     67:                a = (char *)&($$->addr_val);
                     68:                a[0] = $1; a[1] = $3; a[2] = $5; a[3] = $7;
                     69:                $$->addr_link = NOADDR;
                     70:        }
                     71:        ;
                     72: 
                     73: Names  :       NAME
                     74:        = {
                     75:                $$ = $1;
                     76:        }
                     77:        |       NAME ',' Names
                     78:        = {
                     79:                $1->name_link = $3;
                     80:                $$ = $1;
                     81:        }
                     82:        ;
                     83: 
                     84: Cputype :      /* empty */
                     85:        = {
                     86:                $$ = NONAME;
                     87:        }
                     88:        |       NAME
                     89:        = {
                     90:                $$ = $1;
                     91:        }
                     92:        ;
                     93: 
                     94: Opsys  :       /* empty */
                     95:        = {
                     96:                $$ = NONAME;
                     97:        }
                     98:        |       NAME
                     99:        = {
                    100:                $$ = $1;
                    101:        }
                    102:        ;
                    103: 
                    104: Protos :       Proto
                    105:        = {
                    106:                $$ = $1;
                    107:        }
                    108:        |       Proto ',' Protos
                    109:        = {
                    110:                $1->name_link = $3;
                    111:                $$ = $1;
                    112:        }
                    113:        ;
                    114: 
                    115: Proto  :       NAME
                    116:        = {
                    117:                $$ = $1;
                    118:        }
                    119:        ;
                    120: %%
                    121: 
                    122: #include <stdio.h>
                    123: 
                    124: extern int yylineno;
                    125: 
                    126: yyerror(msg)
                    127:        char *msg;
                    128: {
                    129:        fprintf(stderr, "\"%s\", line %d: %s\n", infile, yylineno, msg);
                    130: }

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