sys/netiso/xebec/xebec.bnf

/*
 *      from: unknown
 *      $Id$
 */

{
#include "main.h"
#include "sets.h"
#include <stdio.h>

extern FILE *eventfile_h, *actfile;
}

*fmq

        novocab
        nobnf
        nofirst
        nofollow
        noparsetable
        noerrortables
        nos
        noe

*terminals

ID                      0       0       { char *address; }
STRUCT          0       0
SYNONYM         0       0
PREDICATE               0       0       { char *address; }
ACTION          0       0       { char *address; }
/*
FSTRING         0       0       { char *address; }
*/
PROTOCOL        0       0
LBRACK          0       0
RBRACK          0       0
LANGLE          0       0
EQUAL           0       0
COMMA           0       0
STAR            0       0
EVENTS          0       0
TRANSITIONS     0       0
INCLUDE         0       0
STATES          0       0
SEMI            0       0
PCB                     0       0               { char *address; }
DEFAULT         0       0
NULLACTION      0       0
SAME            0       0

*nonterminals

pcb                             { char *address; int isevent; }
syn                             { int type; }
setlist                 { struct Object *setnum; }
setlisttail             { struct Object *setnum; }
part                    { unsigned char type; }
parttail                { unsigned char type; }
partrest                { unsigned char type; char *address; }
setstruct               { struct Object *object; }
setdef                  { unsigned char type,keep; char *address; struct Object *object; }
translist
transition
event                   { struct Object *object;  }
oldstate                {       struct Object *object;  }
newstate                {       struct Object *object;  }
predicatepart   {       char *string; }
actionpart              {       char *string; struct Object *oldstate; struct Object *newstate; }

*productions

program         ::=
                                STAR PROTOCOL ID
                                {
                                        if(strlen($ID.address) > 50 ) {
                                                fprintf(stderr,
                                                "Protocol name may not exceed 50 chars in length.\n");
                                                Exit(-1);
                                        }
                                        strcpy(protocol, $ID.address);
                                        openfiles(protocol);
                                }
                                STAR includelist
                                PCB
                                {
                                        $$pcb.isevent = 0;
                                }
                                pcb
                                {
                                  fprintf(actfile, "\ntypedef %s %s%s;\n",
                                                          $pcb[7].address,protocol, PCBNAME);
                                  $$syn.type = PCB_SYN;
                                }
                                syn
                                STAR STATES { $$part.type = (unsigned char) STATESET; } part
                                STAR { end_states(eventfile_h); } EVENTS
                                { $$pcb.isevent = 1; }
                                pcb
                                {
                                        fprintf(eventfile_h, "\t"); /* fmq gags on single chars */
                                        includecode(eventfile_h, $pcb[14].address);
                                        fprintf(eventfile_h, "\n"); /* fmq gags on single chars */
                                        $$syn.type = EVENT_SYN;
                                }
                                syn
                                {
                                        $$part.type = (unsigned char)EVENTSET;
                                }
                                part
                                STAR { end_events(); }
                                TRANSITIONS
                                {
                                        putincludes();
                                        putdriver(actfile, 9);
                                }
                                translist
;
pcb     ::=  STRUCT
                         {      if($pcb.isevent)  {
                                        fprintf(stderr,
                                        "Event is a list of objects enclosed by \"{}\"\n");
                                        Exit(-1);
                                }
                          fprintf(eventfile_h, "struct ");
                        }
                         ACTION { $pcb.address = $ACTION.address; }
                         optsemi
                ::=      ACTION
                        {       if( ! $pcb.isevent)  {
                                        fprintf(stderr,
                                        "Pcb requires a type or structure definition.\"{}\"\n");
                                        Exit(-1);
                                }
                           $pcb.address = $ACTION.address;
                        }
                         optsemi
                ::=  ID {  $pcb.address = $ID.address; } optsemi
;

syn ::= SYNONYM ID { synonyms[$syn.type] = stash( $ID.address ); }
                ::=
;

optsemi ::= SEMI
                ::=
;
includelist ::= INCLUDE ACTION { includecode(actfile, $ACTION.address);} STAR
                        ::=
;
part ::= ID
                {
                        $$partrest.address = $ID.address;
                        $$partrest.type = $part.type;
                }
                partrest
                { $$parttail.type = $part.type; }
                parttail
;
parttail ::= { $$part.type = $parttail.type; } part
                ::=
;
partrest ::=  EQUAL
                        {
                          if(  lookup( $partrest.type, $partrest.address ) ) {
                                fprintf(stderr, "bnf:trying to redefine obj type 0x%x, adr %s\n",
                                        $partrest.type, $partrest.address);
                                Exit(-1);
                          }
                          $$setdef.type = $partrest.type;
                          $$setdef.address = stash( $partrest.address );
                          $$setdef.keep = 1;
                        } setdef { $$setstruct.object = $setdef.object; } setstruct

        ::=  ACTION
                {
                 defineitem($partrest.type,
                                        $partrest.address, $ACTION.address);
                }

        ::= {
                        defineitem($partrest.type, $partrest.address, (char *)0);
                }
;

setstruct ::= ACTION
                        {
                                if($setstruct.object)  {
                                        /* WHEN COULD THIS BE FALSE??
                                         * isn't it supposed to be setstruct.object???
                                         * (it used to be $ACTION.address)
                                         */

                                        $setstruct.object->obj_struc = $ACTION.address;
                                        fprintf(eventfile_h,
                                                "struct %s %s%s;\n\n", $ACTION.address,
                                                EV_PREFIX,  $setstruct.object->obj_name);
                                }
                        }
                ::=
;

setdef ::= LBRACK
                {
                        $$setlist.setnum =
                        defineset($setdef.type, $setdef.address, $setdef.keep);
                } setlist RBRACK { $setdef.object = $setlist.setnum; }
;

setlist ::= ID
        {
                member($setlist.setnum, $ID.address);
                                $$setlisttail.setnum = $setlist.setnum;
        } setlisttail
;

setlisttail ::= COMMA { $$setlist.setnum = $setlisttail.setnum; } setlist
                ::=
;
translist               ::=      transition  translisttail
;
translisttail   ::= translist
        ::=
;
transition ::=  newstate { transno ++; } LANGLE EQUAL EQUAL oldstate
        event
        {
                CurrentEvent /* GAG! */ = $event.object;
         }
        predicatepart
        {
                $$actionpart.string = $predicatepart.string;
                $$actionpart.newstate = $newstate.object;
                $$actionpart.oldstate = $oldstate.object;
        }
        actionpart
        SEMI
;

predicatepart ::= PREDICATE
        {
                 $predicatepart.string = stash ( $PREDICATE.address );
        }
        ::= DEFAULT
        {
                $predicatepart.string = (char *)0;
        }
;

actionpart ::=
        ACTION
        {
          statetable( $actionpart.string, $actionpart.oldstate,
                                        $actionpart.newstate,
                                        acttable(actfile, $ACTION.address ),
                                        CurrentEvent );
          if( print_trans ) {
                dump_trans( $actionpart.string, $actionpart.oldstate,
                                        $actionpart.newstate,
                                        $ACTION.address, CurrentEvent );
          }
        }
        ::= NULLACTION
        {
          statetable($actionpart.string, $actionpart.oldstate, $actionpart.newstate,
                                  0, CurrentEvent ); /* KLUDGE - remove this */
          if( print_trans ) {
                dump_trans( $actionpart.string, $actionpart.oldstate,
                                        $actionpart.newstate,
                                        "NULLACTION", CurrentEvent );
          }
        }
;

oldstate ::= ID
        {
                $oldstate.object = Lookup(STATESET, $ID.address);
        }
        ::= {
                        $$setdef.address = (char *)0;
                        $$setdef.type = (unsigned char)STATESET;
                        $$setdef.keep = 0;
                }
                setdef
                {
                        $oldstate.object = $setdef.object;
                }
;

newstate ::= ID
        {
                $newstate.object = Lookup(STATESET, $ID.address);
        }
;

newstate ::= SAME
        {
                extern struct Object *SameState;

                $newstate.object = SameState;
        }
;

event ::= ID
                {
                        $event.object = Lookup(EVENTSET, $ID.address);
                }
        ::=
                {
                        $$setdef.address = (char *)0;
                        $$setdef.type = (unsigned char)EVENTSET;
                        $$setdef.keep = 0;
                }
                setdef
                {
                        $event.object = $setdef.object;
                }
;

*end