Subversion Repositories Vertical

/*

 * hdl.y parser for verilog net lists 

 *  by  Frank Bennett 

 *

 * i.e. hdl s.g 

 * products two files: s.nam, s.seq - 1 net per line

 *   s.seq is sorted by reference designator

 *   s.nam is sorted by netname

 *

 * - primarily handles "flat" verilog HDL netlists.

 * - parses hierarchical netlist but currently doesn't flatten them.

 * - concatenated signal names need to be expanded. currently the whole

 *   netname bundle is given the name : "concatenation"

 * - not included :

 * 	Behavioral Statements

 *	Specify blocks

 *

 *  PD yacc :

 * byacc, Bob Corbett. Berkely yacc adapted for MINIX by Peter Housel

 * COLOGNE:commands/lex-yacc/byacc.tar.Z

 *

 * DOS extender - 386 to avoid malloc problems

 * djgpp.zip 

 * wuarchive.wustl.edu   (128.252.135.4): /mirrors3/garbo.uwasa.fi/programming

 */

%{

#define YYDEBUG 1

#include <string.h>

#include <ctype.h>

#include <errno.h>

#include <stdio.h>

#include <fcntl.h>

#define out(c) putc(c,yyout)

#define NCOM 300

int	bug=0, ind ;

FILE 	*fopen(), *freopen(), *fi, *ft, *fo, *fr ;

static 	int i, comment=0;

char  	*cp, *st, refd[20], part[20] ;

char	ln[80] ;

extern char 	*strsave(), *malloc();

extern int	yyleng, lexval ;

extern char	yytext[];

extern char	yysbuf[];

typedef struct YYS_TYPE { /* use instead of %union below */

    int i;

    char s[50];

    } yys_type ;

#define YYSTYPE     yys_type

# define YYLMAX 132

int	yylineno =0;

int	yyleng ;

char	yytext[YYLMAX];

char	yysbuf[YYLMAX];

char 	modnam[YYLMAX];

int 	yysptr = -1, yylast, toklast;

FILE	*yyout;

#define YYNL 10

%}

/* HP-UX yacc seems to be fussy about :

%union {

    int i;

    char s[50];

    }

 */

%token NL NAME NUMBER MODULE ENDMODULE WIRE INPUT OUTPUT INOUT

%token NETTYPE ASSIGN STRENGTH0 STRENGTH1 GATETYPE INITIAL

%token PARAMETER REG TIME INTEGER REAL EVENT DEFPARAM

%token BIN_OP UNARY_OP PRIMITIVE ENDPRIM TABLE ENDTABLE

%token OUT_SYM LEV_SYM EDGE_SYM

%left BIN_OP

%start modules

%%

modules 	: modules mod_prim

		| modules         error

		|      	  mod_prim

		;

mod_prim	: module

		| primitive

		;

primitive	: PRIMITIVE NAME '(' list_of_vars ')' ';' prim_body ENDPRIM

		;

list_of_vars	: list_of_vars ',' NAME

		| NAME

		;

prim_body	: UDP_decl UDP_init table_def

		| UDP_decl          table_def

		;

UDP_decl	: output_decl

		| input_decl

		| reg_decl

		;

UDP_init	: INITIAL NAME '=' init_val

		;

init_val	: '1' '\'' 'b' '0'

		| '1' '\'' 'b' '1'

		| '1' '\'' 'b' 'x'

		| '1'

		| '0'

		;

table_def	: TABLE table_entries ENDTABLE

		;

table_entries	: table_entries combin_entry

		|               combin_entry

		| table_entries seq_entry

		|               seq_entry

		;

combin_entry	: level_in_list ':' OUT_SYM ';'

		;

seq_entry	: level_in_list ':' state ':' next_state ';'

		|  edge_in_list ':' state ':' next_state ';'

		;

level_in_list 	: LEV_SYM

		;

edge_in_list	: LEV_SYM edge LEV_SYM

		|         edge

		;

edge		: '(' LEV_SYM LEV_SYM ')'

		| EDGE_SYM

		;

state		: LEV_SYM

		;

next_state	: OUT_SYM

		;

module		: MODULE NAME ';' mod_body ENDMODULE 

      	 	| MODULE NAME '('list_of_ports')' ';' mod_body ENDMODULE 

		;

list_of_ports	: list_of_ports ',' port

		| port

		;

port		: NAME

		| NAME '[' const_exp ']'

		| NAME '[' const_exp ':' const_exp ']'

		;

mod_body	: mod_body module_item 

		|          module_item 

		;

module_item	: param_decl

		| input_decl

		| output_decl

		| inout_decl

		| net_decl

		| reg_decl

		| time_decl

		| integer_decl

		| real_decl

		| event_decl

		| gate_decl

		| module_instant

		| defparm_decl

		| cont_assign

		;

param_decl	: PARAMETER

		;

reg_decl	: REG

		;

time_decl	: TIME

		;

integer_decl	: INTEGER

		;

real_decl	: REAL

		;

event_decl	: EVENT

		;

defparm_decl	: DEFPARAM

		;

gate_decl	: GATETYPE                   gate_instant

		| GATETYPE dr_strength       gate_instant

		| GATETYPE             delay gate_instant

		| GATETYPE dr_strength delay gate_instant

		;

gate_instant	: NAME '(' exp ')'

		;

input_decl	: INPUT       list_vars ';'

		| INPUT range list_vars ';'

		;

output_decl	: OUTPUT       list_vars ';'

		| OUTPUT range list_vars ';'

		;

inout_decl	: INOUT       list_vars ';'

		| INOUT range list_vars ';'

		;

net_decl	: NETTYPE             list_vars ';'

		| NETTYPE range       list_vars ';'

		| NETTYPE       delay list_vars ';'

		| NETTYPE range delay list_vars ';'

		;

range		: '[' const_exp ':' const_exp ']' 

		;

delay		: '#' number

		| '#' NAME

		;

dr_strength	: '(' STRENGTH0 ',' STRENGTH1 ')'

		| '(' STRENGTH1 ',' STRENGTH0 ')'

		;

list_vars	: list_vars ',' NAME

		|               NAME

		;

module_instant	: name_mod         mod_inst_list ';' 

              	| name_mod par_val mod_inst_list ';' 

		;

name_mod	: NAME

		{ strcpy( part, yytext); }

		;

mod_inst_list	: mod_inst_list ',' mod_inst

		|                   mod_inst

		;

mod_inst	: reference '(' list_mod_conn ')'

        	| reference '(' list_nam_conn ')'

		;

reference	: NAME

		{ strcpy( refd, yytext); }

		;

list_mod_conn	: list_mod_conn ',' exp

		|                   exp

		;

list_nam_conn	: list_nam_conn ',' nam_conn

		|                   nam_conn

		;

nam_conn	: '.' NAME '(' sig_nam ')'

		{

		    fprintf(fo,"%-18s %-22s %-10s %10s %s\n",

			 $4.s, refd, $2.s, part, modnam);

		}

		;

sig_nam		: NAME

		| NAME '[' exp ']'

		{ strcpy($$.s, $1.s);

		  strcat($$.s, "[");

		  strcat($$.s, $3.s);

		  strcat($$.s, "]");

		}

		| NAME '[' exp ':' exp ']'

		{ strcpy($$.s, $1.s);

		  strcat($$.s, "[");

		  strcat($$.s, $3.s);

		  strcat($$.s, ":");

		  strcat($$.s, $5.s);

		  strcat($$.s, "]");

		}

		| concatenation

		{ strcpy($$.s, "concatenation");}

		;

par_val		: '#' '(' exp ')' 

		;

cont_assign	: ASSIGN                   list_assigns ';'

		| ASSIGN dr_strength       list_assigns ';'

		| ASSIGN             delay list_assigns ';'

		| ASSIGN dr_strength delay list_assigns ';'

		;

list_assigns	: list_assigns ',' assignment

		|                  assignment

		;

assignment	: lvalue '='     exp

		| lvalue '=' '(' exp ')'

		;

lvalue		: NAME

		| NAME '[' exp ']'

		| concatenation

		;

const_exp	: exp

		;

concatenation	: '{' exp_list '}'

		;

exp_list	: exp_list ',' exp

		|              exp

		;

exp		: primary

		| UNARY_OP primary

		| UNARY_OP '(' exp ')'

		| exp BIN_OP exp

		;

primary		: number

		| NAME '[' exp ']'

		| NAME

		| concatenation

		;

number		: NUMBER

		| NUMBER '\'' 'b' NUMBER

		| NUMBER '\'' 'd' NUMBER

		| NUMBER '\'' 'o' NUMBER

		;

%%	/* start of main */

main(argc,argv)

int	argc;

char	*argv[];

{

    int	i,p;

    char frnam[60], fsnam[60];

    yyout =stderr;

    if(argc == 1) {

	fprintf(stderr,"use:hdl [-ds] file\n"); exit(1);

    }

    for(i=1; i<argc; i++)

    	if(argv[i][0] == '-'){

		bug     = ((argv[i][1] == 'd') || (argv[i][2] == 'd'));

	}

	else break;

    if(freopen( argv[i],"r",stdin) == NULL){

	fprintf(stderr,"can't open %s\n", argv[i]);exit(1);

    }	else {

	/* open output */

	for( cp=argv[i], st=fsnam ; *cp && *cp != '.' ; )*st++ = *cp++;

	*st = 0;

	strcpy( frnam, fsnam );	

	strcat( frnam, ".nam");	strcat( fsnam, ".seq");

	if((fo = fopen(fsnam, "w")) == NULL) err("can't open %s",fsnam);

	fprintf(stderr,"reading nets from %s\n", argv[i]);

    }

    yyparse() ;

    fclose(fo);

    fprintf(stderr,"sorting...\n");

    sprintf(ln, "sort <%s >%s", fsnam, frnam);	system(ln);

}

int 

yylex() /* Gets the next token from the input stream */

{

	int  c, i, j ;

	static int eline ; 

	extern int bug;

start:

	if(yysptr == -1){

		i = 0;	eline =1; yylineno++;

		/* get line to yysbuf */

		while( ((c=getchar()) != EOF) && (c != YYNL)){

			if(c == '\t'){ c=' ';do yysbuf[i++] = c; while(i & 7);}

			else	{

				if (c != ' ')eline =0;	

				yysbuf[i++] = c;

			}

		}

		yysptr = 0;

		yysbuf[i] = '\0';

		yylast = toklast = 0;

	}

	if(c == EOF) 

	    return(EOF);

	while( (c = yysbuf[yysptr]) == ' ') yysptr++;

	if(bug){

		fprintf(yyout,"%03d:%s\n",yylineno,yysbuf);

		for( i=yysptr ; i>0 ; i-- )out(' ');

	}

	 if ( c == YYNL || c== 0 ){ 

		yysptr= -1;

		if(bug)fprintf(yyout,"\n");

		goto start;

	 } 

	 if( comment ){

		while( (c = yysbuf[yysptr++]) != '*' && c != '/'&& c );

		if( c == '*' && yysbuf[yysptr]=='/' )

		    comment-- ;

	        if( c == '/' && yysbuf[yysptr]=='*' )

		    comment++ ;

		if( c ==  0  )

		    yysptr = -1;

		if( comment )

		    goto start;

		yysptr++;

		    goto start;

	 }

	 if( c == '/' ) { /* comment // ? */

	     if( yysbuf[yysptr+1] == '/') {

	     	yysptr= -1;

	     	goto start;

	     }

	     if( yysbuf[yysptr+1] == '*') {

		comment++; yysptr +=2;

		goto start;

	     }

	 }

	 if( c == '\\'){ /* escaped name */

 		yyleng=0;

	        while( (c=yysbuf[++yysptr]) != ' ' ) 

	                yytext[yyleng++] = c;

		yytext[yyleng] = '\0'; 

	        if(bug)fprintf(yyout,"    ^tok:NAME\n");

		if( toklast==MODULE ){

		    toklast = 0;

		    strcpy(modnam, yytext);

		    fprintf(stderr,"module %s\n", modnam);

		}

		if( toklast==PRIMITIVE ){

		    toklast = 0;

		    strcpy(modnam, yytext);

		    fprintf(stderr,"primitive %s\n", modnam);

		}

		strcpy(yylval.s, yytext);

		return(NAME);

	 }

	 if( isalpha(c) ) {

		if( yylast == '\'' ){ /* number base - 1'b0 */

		    yysptr++;

	 	    if(bug)

         	       if(c < ' ')   fprintf(yyout,"    ^CHAR:%d\n",c);

			      else   fprintf(yyout,"    ^CHAR:%c\n",c);

	            yylast = c;

	            return(c);

		}

		if( (j=chktok()) != 0){

		    toklast = j; 

		    return(j);

		}

        name:

 		yyleng=0;

	        while( isalpha(c) || isdigit(c) || c=='_' ) {

	                yytext[yyleng++] = c; c = yysbuf[++yysptr];

       		}

		yytext[yyleng] = '\0'; 

	        if(bug)fprintf(yyout,"    ^tok:NAME\n");

		if( toklast==MODULE ){

		    toklast = 0;

		    strcpy(modnam, yytext);

		    fprintf(stderr,"module %s\n", modnam);

		}

		if( toklast==PRIMITIVE ){

		    toklast = 0;

		    strcpy(modnam, yytext);

		    fprintf(stderr,"primitive %s\n", modnam);

		}

		strcpy(yylval.s, yytext);

		return(NAME);

	 } 

	 if( isdigit(c) ) {

 		yyleng=0;

	        while( isdigit(c) ) {

	                yytext[yyleng++] = c; c = yysbuf[++yysptr];

       		}

		yytext[yyleng] = '\0'; 

	        if(bug)fprintf(yyout,"    ^tok:NUMBER\n");

		strcpy(yylval.s, yytext);

		return(NUMBER);

	 }

	 yysptr++; yylast = c;

	 if( c=='+' || c=='-' || c=='&' || c=='|' || c=='^' ){

	     if(bug) fprintf(yyout,"    ^BIN_OP:%c\n",c);

	     return(BIN_OP);

	 }

	 if( c=='!' || c=='~' ){

	     if(bug) fprintf(yyout,"    ^UNARY_OP:%c\n",c);

	     return(UNARY_OP);

	 }

	 if(bug)

	     if(c < ' ')

		fprintf(yyout,"    ^CHAR:%d\n",c);

	     else

		fprintf(yyout,"    ^CHAR:%c\n",c);

	 return(c);

} /* nexttoken */

int chktok()

{

    static struct { char *keyword; int val, tok; } key [] = {

	"module " ,   0, MODULE,

	"endmodule" , 0, ENDMODULE, 

	"primitive ", 0, PRIMITIVE,

	"endprimitive",0,ENDPRIM,

	"input "    , 0, INPUT,

	"output "   , 0, OUTPUT,

	"inout "    , 0, INOUT,

	"assign "   , 0, ASSIGN,

	"wire "     , 0, NETTYPE,

	"triand "   , 1, NETTYPE,

	"trior "    , 2, NETTYPE,

	"tri1 "     , 3, NETTYPE,

	"tri "      , 4, NETTYPE,

	"supply0 "  , 5, NETTYPE,

	"supply1 "  , 6, NETTYPE,

	"wor "      , 7, NETTYPE,

	"trireg "   , 8, NETTYPE,

	"supply0 "  , 0, STRENGTH0,

	"strong0 "  , 1, STRENGTH0,

	"pull0 "    , 2, STRENGTH0,

	"weak0 "    , 3, STRENGTH0,

	"highz0 "   , 4, STRENGTH0,

	"supply1 "  , 0, STRENGTH1,

	"strong1 "  , 1, STRENGTH1,

	"pull1 "    , 2, STRENGTH1,

	"weak1 "    , 3, STRENGTH1,

	"highz1 "   , 4, STRENGTH1,

	"parameter ", 0, PARAMETER,

	"reg "	    , 0, REG,

	"time "	    , 0, TIME,

	"integer "  , 0, INTEGER,

	"real "     , 0, REAL,

	"event "    , 0, EVENT,

	"defparam " , 0, DEFPARAM,

	"and "	    , 0, GATETYPE,

	"nand "     , 1, GATETYPE,

	"or " 	    , 2, GATETYPE,

	"nor "      , 3, GATETYPE,

	"xor "	    , 4, GATETYPE,

	"xnor "     , 5, GATETYPE,

	"buf "	    , 6, GATETYPE,

	"tran "     , 7, GATETYPE,

	"table "    , 0, TABLE,

	"endtable"  , 0, ENDTABLE,

	"initial "  , 0, INITIAL,

	NULL, 0, 0

	};

    int	save, i, j ;

    char	*s; 

    for( j=0 ; (s=key[j].keyword) != NULL ; j++) {

	save = yysptr; yyleng = 0;

	while( *s == yysbuf[yysptr++] && *s )

	    yytext[yyleng++] = *s++;

	if(*s == '\0'){

	    yytext[yyleng] = '\0';

	    yysptr--;

	    if(bug){

		for( i=yysptr-1 ; i>0 ; i-- )out(' ');

		fprintf(yyout,"    ^tok:%s\n",yytext);

	    }

	    yylval.i = key[j].val;

	    return(key[j].tok);

        }

        yysptr = save;

    }

    return(0);

}

yyerror(s)

char	*s;

{

    int  i;

    fprintf(stderr,"%s error on line %d\n",s,yylineno);

    fprintf(stderr,"%s\n", yysbuf);

    for( i=yysptr ; i>0 ; i-- )out(' ');

    fprintf(stderr,"^\n");

}

char *strsave(s)

char *s;

{

    char *p, *malloc();

    if((p = malloc(strlen(s)+1)) != NULL) strcpy(p,s);

    if( p==NULL)err("out of malloc space");

    return(p);

}

err(s,t)

char *s,*t;

{

    fprintf(stderr,s,t); fprintf(stderr,"\n");

    exit(1);

}