vhd2vl.y

將VHDL設計轉換成Verilog設計的程式

           $$=addsl(sl,$7);
         }
       ;

p_body : rem {$$=$1;}
       | rem signal ':' '=' expr ';' doothers p_body {
         slist *sl;
           sl=addsl($1,indents[indent]);
           sl=addsl(sl,$2->sl);
           fixothers($2,$7);
           sl=addtxt(sl," = ");
           if($5->op == 'c')
             sl=addsl(sl,addwrap("{",$5->sl,"}"));
           else
             sl=addsl(sl,$5->sl);
           free($5);
           sl=addtxt(sl,";\n");
           $$=addsl(sl,$8);
         }
       | rem signal '<' '=' sigvalue doothers p_body {
         slist *sl;
         sglist *sg;
         char *s;

	   s=bottom($2->sl);
           if((sg=lookup(io_list,s))==NULL)
             sg=lookup(sig_list,s);
           if(sg)
             sg->type=reg;
           sl=addsl($1,indents[indent]);
           sl=addsl(sl,$2->sl);
           fixothers($2,$6);
           sl=addtxt(sl," <= ");
           sl=addsl(sl,$5);
           sl=addtxt(sl,";\n");
           $$=addsl(sl,$7);
         }
       | rem IF exprc THEN doindent p_body unindent elsepart END IF ';' p_body {
         slist *sl;
           sl=addsl($1,indents[indent]);
           sl=addtxt(sl,"if(");
           sl=addsl(sl,$3);
           sl=addtxt(sl,") begin\n");
           sl=addsl(sl,$6);
           sl=addsl(sl,indents[indent]);
           sl=addtxt(sl,"end\n");
           sl=addsl(sl,$8);
           $$=addsl(sl,$12);         
         }
       | rem CASE signal IS rem cases END CASE ';' p_body {
         slist *sl;
           sl=addsl($1,indents[indent]);
           sl=addtxt(sl,"case(");
           sl=addsl(sl,$3->sl);
           sl=addtxt(sl,")\n");
           if($5){
             sl=addsl(sl,indents[indent]);
             sl=addsl(sl,$5);
           }
           sl=addsl(sl,$6);
           sl=addsl(sl,indents[indent]);
           sl=addtxt(sl,"endcase\n");
           $$=addsl(sl,$10);           
         }
       | rem NULLV ';' p_body {
         slist *sl;
           if($1){
             sl=addsl($1,indents[indent]);
             $$=addsl(sl,$4);
           }else
             $$=$4;
         }
       ;

elsepart : {$$=NULL;}
         | ELSIF exprc THEN doindent p_body unindent elsepart {
           slist *sl;
             sl=addtxt(indents[indent],"else if(");
             sl=addsl(sl,$2);
             sl=addtxt(sl,") begin\n");
             sl=addsl(sl,$5);
             sl=addsl(sl,indents[indent]);
             sl=addtxt(sl,"end\n");
             $$=addsl(sl,$7);
           }
         | ELSE doindent p_body unindent {
           slist *sl;
             sl=addtxt(indents[indent],"else begin\n");
             sl=addsl(sl,$3);
             sl=addsl(sl,indents[indent]);
             $$=addtxt(sl,"end\n");
           }
         ;

cases : WHEN wlist '=' '>' doindent p_body unindent cases{
        slist *sl;
          sl=addsl(indents[indent],$2);
          sl=addtxt(sl," : begin\n");
          sl=addsl(sl,$6);
          sl=addsl(sl,indents[indent]);
          sl=addtxt(sl,"end\n");
          $$=addsl(sl,$8);
        }
      | WHEN OTHERS '=' '>' doindent p_body unindent {
        slist *sl;
          sl=addtxt(indents[indent],"default : begin\n");
          sl=addsl(sl,$6);
          sl=addsl(sl,indents[indent]);
          $$=addtxt(sl,"end\n");
        }
      ;

wlist : wvalue {$$=$1;}
      | wlist '|' wvalue {
        slist *sl;
	  sl=addtxt($1,",");
          $$=addsl(sl,$3);
        }
      ;

wvalue : STRING {$$=addvec(NULL,$1);}
       | NAME {$$=addtxt(NULL,$1);}
       ;

sign_list : signal {$$=$1->sl; free($1);}
          | signal ',' sign_list {
            slist *sl;
              sl=addtxt($1->sl," or ");
              free($1);
              $$=addsl(sl,$3);
            }
          ;

sigvalue : expr delay ';' {
           slist *sl;
	     if(delay && $2){
               sl=addtxt(NULL,"# ");
               sl=addval(sl,$2);
               sl=addtxt(sl," ");
             } else
               sl=NULL;
             if($1->op == 'c')
               sl=addsl(sl,addwrap("{",$1->sl,"}"));
             else
               sl=addsl(sl,$1->sl);
             free($1);
             delay=1;
             $$=sl;
           }
         | expr delay WHEN exprc ';' {
	     fprintf(stderr,"Warning on line %d :\nCan't translate expr delay WHEN exprc';' expressions\n",lineno);
             $$=NULL;
           }
         | expr delay WHEN exprc ELSE nodelay sigvalue {
           slist *sl;
	     sl=addtxt($4," ? ");
             if($1->op == 'c')
               sl=addsl(sl,addwrap("{",$1->sl,"}"));
             else
	       sl=addsl(sl,$1->sl);
             free($1);
	     sl=addtxt(sl," : ");
	     $$=addsl(sl,$7);
           }
         ;

nodelay  : /* empty */ {delay=0;}
         ;

delay    : /* empty */ {$$=0;}
         | AFTER NATURAL UNIT {$$=$2;}
         ;

map_list : rem map_item {
           slist *sl;
           sl=addsl($1,indents[indent]);
           $$=addsl(sl,$2);}
         | rem map_item ',' map_list {
           slist *sl;
             sl=addsl($1,indents[indent]);
	     sl=addsl(sl,$2);
	     sl=addtxt(sl,",\n");
	     $$=addsl(sl,$4);
           }
         ;

map_item : signal {$$=$1->sl; free($1);}
         | NAME '=' '>' signal {
           slist *sl;
	     sl=addtxt(NULL,".");
	     sl=addtxt(sl,$1);
	     sl=addtxt(sl,"(");
	     sl=addsl(sl,$4->sl);
             free($4);
	     $$=addtxt(sl,")");
           }
         ;

signal : NAME {
         slist *sl;
         slval *ss;

	   ss=(slval *) malloc(sizeof(slval));
           sl=addtxt(NULL,$1);
           if(dowith){
             slwith=sl;
             dowith=0;
           }
           ss->sl=sl;
           ss->val=-1;
           $$=ss;
         }
       | NAME '('vec_range ')' {
         slval *ss;
         slist *sl;
	   ss=(slval *) malloc(sizeof(slval));
           sl=addtxt(NULL,$1);
           sl=addpar(sl,$3);
           if(dowith){
             slwith=sl;
             dowith=0;
           }
           ss->sl=sl;
           if($3->hi==-1)
             ss->val=1;
           else
             ss->val=abs($3->hi-$3->lo)+1;
           free($3);
           $$=ss;
         }
       ;

/* Expressions */
expr : signal {
         expdata *e;
           e=(expdata *) malloc(sizeof(expdata));
           e->op='t'; /* Terminal symbol */
           e->sl=$1->sl;
           free($1);
           $$=e;
         }
     | STRING {
         expdata *e;
           e=(expdata *) malloc(sizeof(expdata));
           e->op='t'; /* Terminal symbol */
           e->sl=addvec(NULL,$1);
           $$=e;
         }
     | '(' OTHERS '=' '>' STRING ')' {
         expdata *e;
           e=(expdata *) malloc(sizeof(expdata));
           e->op='t'; /* Terminal symbol */
           if(others0 == NULL){
             others0=addtxt(NULL,"{");
             others0=addval(others0,0);
             others0=addtxt(others0,oth0);
             others1=addtxt(NULL,"{");
             others1=addval(others1,0);
             others1=addtxt(others1,oth1);
           }
           e->sl=$5[0] == '0' ? others0 : others1;
           $$=e;
         }
     | expr '&' expr { /* Vector chaining */
         slist *sl;
           sl=addtxt($1->sl,",");
           sl=addsl(sl,$3->sl);
           free($3);
           $1->op='c';
           $1->sl=sl;
           $$=$1;
         }
     | '-' expr %prec UMINUS {$$=addexpr(NULL,'m'," -",$2);}
     | '+' expr %prec UPLUS {$$=addexpr(NULL,'p'," +",$2);}
     | expr '+' expr {$$=addexpr($1,'+'," + ",$3);}
     | expr '-' expr {$$=addexpr($1,'-'," - ",$3);}
     | expr '*' expr {$$=addexpr($1,'*'," * ",$3);}
     | expr '/' expr {$$=addexpr($1,'/'," / ",$3);}
     | NOT expr {$$=addexpr(NULL,'~'," ~",$2);}
     | expr AND expr {$$=addexpr($1,'&'," & ",$3);}
     | expr OR expr {$$=addexpr($1,'|'," | ",$3);}
     | expr XOR expr {$$=addexpr($1,'^'," ^ ",$3);}
     | '(' expr ')' {$$=$2; }
     ;

/* Conditional expressions */
exprc : conf { $$=$1; }
      | '(' exprc ')' {$$=addwrap("(",$2,")");}
      | exprc AND exprc %prec ANDL {
        slist *sl;
          sl=addtxt($1," && ");
          $$=addsl(sl,$3);
        }
      | exprc OR exprc %prec ORL {
        slist *sl;
          sl=addtxt($1," || ");
          $$=addsl(sl,$3);
        }
      | NOT exprc %prec NOTL {
        slist *sl;
          sl=addtxt(NULL,"!");
          $$=addsl(sl,$2);
        }
      ;

/* Comparisons */
conf : expr '=' expr %prec EQUAL {
       slist *sl;
         if($1->op == 'c')
           sl=addwrap("{",$1->sl,"} == ");
         else if($1->op != 't')
           sl=addwrap("(",$1->sl,") == ");
         else
           sl=addtxt($1->sl," == ");
         if($3->op == 'c')
           $$=addsl(sl,addwrap("{",$3->sl,"}"));
         else if($3->op != 't')
           $$=addsl(sl,addwrap("(",$3->sl,")"));
         else
           $$=addsl(sl,$3->sl);
         free($1);
         free($3);
       }
     | expr '>' expr {
       slist *sl;
         if($1->op == 'c')
           sl=addwrap("{",$1->sl,"} > ");
         else if($1->op != 't')
           sl=addwrap("(",$1->sl,") > ");
         else
           sl=addtxt($1->sl," > ");
         if($3->op == 'c')
           $$=addsl(sl,addwrap("{",$3->sl,"}"));
         else if($3->op != 't')
           $$=addsl(sl,addwrap("(",$3->sl,")"));
         else
           $$=addsl(sl,$3->sl);
         free($1);
         free($3);
       }
     | expr '>' '=' expr %prec BIGEQ {
       slist *sl;
         if($1->op == 'c')
           sl=addwrap("{",$1->sl,"} >= ");
         else if($1->op != 't')
           sl=addwrap("(",$1->sl,") >= ");
         else
           sl=addtxt($1->sl," >= ");
         if($4->op == 'c')
           $$=addsl(sl,addwrap("{",$4->sl,"}"));
         else if($4->op != 't')
           $$=addsl(sl,addwrap("(",$4->sl,")"));
         else
           $$=addsl(sl,$4->sl);
         free($1);
         free($4);
       }
     | expr '<' expr {
       slist *sl;
         if($1->op == 'c')
           sl=addwrap("{",$1->sl,"} < ");
         else if($1->op != 't')
           sl=addwrap("(",$1->sl,") < ");
         else
           sl=addtxt($1->sl," < ");
         if($3->op == 'c')
           $$=addsl(sl,addwrap("{",$3->sl,"}"));
         else if($3->op != 't')
           $$=addsl(sl,addwrap("(",$3->sl,")"));
         else
           $$=addsl(sl,$3->sl);
         free($1);
         free($3);
       }
     | expr '<' '=' expr %prec LESSEQ {
       slist *sl;
         if($1->op == 'c')
           sl=addwrap("{",$1->sl,"} <= ");
         else if($1->op != 't')
           sl=addwrap("(",$1->sl,") <= ");
         else
           sl=addtxt($1->sl," <= ");
         if($4->op == 'c')
           $$=addsl(sl,addwrap("{",$4->sl,"}"));
         else if($4->op != 't')
           $$=addsl(sl,addwrap("(",$4->sl,")"));
         else
           $$=addsl(sl,$4->sl);
         free($1);
         free($4);
       }
     | expr '/' '=' expr %prec NOTEQ {
       slist *sl;
         if($1->op == 'c')
           sl=addwrap("{",$1->sl,"} != ");
         else if($1->op != 't')
           sl=addwrap("(",$1->sl,") != ");
         else
           sl=addtxt($1->sl," != ");
         if($4->op == 'c')
           $$=addsl(sl,addwrap("{",$4->sl,"}"));
         else if($4->op != 't')
           $$=addsl(sl,addwrap("(",$4->sl,")"));
         else
           $$=addsl(sl,$4->sl);
         free($1);
         free($4);
       }
     ;
%%

char *outfile;    /* Output file */
char *sourcefile; /* Input file */

main(int argc, char *argv[]){
int i,j;
char *s;
slist *sl;

  fprintf(stderr, "vhd2vl v 1.0,  VHDL to Verilog RTL translator\n");
  fprintf(stderr, "Copyright (C) 2001 Vincenzo Liguori - Ocean Logic Pty Ltd - http://www.ocean-logic.com\n");
  fprintf(stderr, "vhd2vl comes with ABSOLUTELY NO WARRANTY\n");
  fprintf(stderr, "This is free software, and you are welcome to redistribute it\n");
  fprintf(stderr, "under certain conditions.\n"); 
  fprintf(stderr, "See the license file license.txt included with the source for details.\n\n");

  /* Init the indentation variables */
  indents[0]=NULL;
  for(i=1;i<MAXINDENT;i++){
    indents[i]=sl=(slist *) malloc(sizeof(slist));
    sl->data.txt=s=(char *) malloc(sizeof(char) *((i<<1)+1));
    for(j=0;j<(i<<1);j++)
      *s++=' ';
    *s=0;
    sl->type=1;
    sl->slst=NULL;
  }

  sourcefile = argv[1];
  outfile = argv[2];

  if (!freopen(sourcefile, "r", stdin)) {
     fprintf(stderr, "Error: Can't open input file '%s'\n", sourcefile);
     return(1);
     }

  if (!freopen(outfile, "w", stdout)) {
     fprintf(stderr, "Error: Can't open output file '%s'\n", outfile);
     fclose(stdin);
     return(1);
     }

  printf("// File translated with vhd2vl v 1.0\n// VHDL to Verilog RTL translator\n");
  printf("// Copyright (C) 2001 Vincenzo Liguori - Ocean Logic Pty Ltd - http://www.ocean-logic.com\n");
  printf("// vhd2vl comes with ABSOLUTELY NO WARRANTY\n");
  printf("// This is free software, and you are welcome to redistribute it\n");
  printf("// under certain conditions.\n"); 
  printf("// See the license file license.txt included with the source for details.\n\n");

  yyparse();
  fclose(stdout);
  fclose(stdin);
}