vhd2vl.y

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

                  p=p->next;
                  if(p==NULL)
                    break;
                  sl=addtxt(sl,", ");
                }
                sl=addtxt(sl,";\n");
                sl=addsl(sl,$6);
                $$=addsl(sl,$7);
                p=$1;
                for(;;){
                  p->type=wire;
                  p->range=$4;
                  if(p->next==NULL)
                    break;
                  p=p->next;
                }
                p->next=io_list;
                io_list=$1;
              } else{
                free($6);
                free($4);
              }
            }
          ;

dir         : IN { $$=0;}
            | OUT { $$=1; }
            ;

type        : BIT {
                $$=(vrange *) malloc(sizeof(vrange));
                $$->hi=-2;
              }
            | BITVECT '('vec_range ')' {$$=$3;}
            | NAME {
              sglist *sg;

	        sg=lookup(type_list,$1);
                if(sg)
                  $$=sg->range;
                else{
                  fprintf(stderr,"Undefined type on line %d\n",lineno);
                  YYABORT;
                }
	      }
            ;

vec_range : NATURAL updown NATURAL {
              $$=(vrange *) malloc(sizeof(vrange));
              $$->hi=$1;
              $$->lo=$3;  
            }
          | NATURAL {
              $$=(vrange *) malloc(sizeof(vrange));
              $$->hi=-1;
              $$->lo=$1;  
            }
          ;

updown : DOWNTO {}
       | TO {}
       ;

/* Architecture */
architecture : ARCHITECTURE NAME OF NAME IS rem a_decl
               BEGN doindent a_body END NAME ';' unindent { 
               slist *sl;

                 sl=addsl($6,$7);
                 sl=addtxt(sl,"\n");
                 $$=addsl(sl,$10);
               }
             ;

/* Extends indentation by one level */
doindent : /* Empty */ {indent= indent < MAXINDENT ? indent + 1 : indent;}
         ;
/* Shorten indentation by one level */
unindent : /* Empty */ {indent= indent > 0 ? indent - 1 : indent;}

/* Declarative part of the architecture */
a_decl    : {$$=NULL;}
          | a_decl SIGNAL s_list ':' type ';' rem {
            sglist *sg;
            slist *sl;
            int size;

              if($5->hi==-1)
                size=1;
              else
                size=($5->hi)-($5->lo);
	      sl=$1;
              sg=$3;
	      for(;;){
                sg->type=wire;
                sg->range=$5;
                sl=addptxt(sl,&(sg->type));
                sl=addpar(sl,$5);
                sl=addtxt(sl,sg->name);
                sl=addtxt(sl,";\n");
	        if(sg->next == NULL)
                  break;
                sg=sg->next;
              }
              sg->next=sig_list;
              sig_list=$3;
              $$=addsl(sl,$7);
            }
          | a_decl CONSTANT NAME ':' type ':' '=' STRING ';' rem {
	    slist * sl;
              sl=addtxt($1,"parameter ");
              sl=addpar(sl,$5);
              free($5);
              sl=addtxt(sl,$3);
              sl=addtxt(sl," = ");
              sl=addvec(sl,$8);
              sl=addtxt(sl,";\n");
              $$=addsl(sl,$10);
            }
          | a_decl TYPE NAME IS '(' s_list ')' ';' rem {
	    slist * sl,*sl2;
            sglist *p;
            int n,k;
	      n=0;
	      sl=NULL;
	      p=$6;
              for(;;){
                sl=addtxt(sl,"  ");
                sl=addtxt(sl,p->name);
                sl=addtxt(sl," = ");
                sl=addval(sl,n++);
                p=p->next;
                if(p==NULL){
                  sl=addtxt(sl,";\n");
                  break;
                } else
                  sl=addtxt(sl,",\n");
              }
              n--;
              k=0;
              if(n&0xff00){
                k|=8;
                n&=0xff00;
              }
              if(n&0xf0f0){
                k|=4;
                n&=0xf0f0;
              }
              if(n&0xcccc){
                k|=2;
                n&=0xcccc;
              }
              if(n&0xaaaa){
                k|=1;
                n&=0xaaaa;
              }
              sl2=addtxt(NULL,"parameter [");
              sl2=addval(sl2,k);
              sl2=addtxt(sl2,":0]\n");
              sl=addsl(sl2,sl);
              sl=addsl($1,sl);
              $$=addsl(sl,$9);
              p=(sglist *) malloc(sizeof(sglist));
              p->name=$3;
              p->range=(vrange *) malloc(sizeof(vrange));
              p->range->lo=0;
              if(k>0)
                p->range->hi=k;
              else
                p->range->hi=-1;
              p->next=type_list;
              type_list=p;
	    }
          | a_decl COMPONENT NAME PORT nolist '(' rem portlist ')' ';' rem END COMPONENT ';' yeslist rem {
	      $$=addsl($1,$16);
              free($3);
              free($7);
              free($11);
            }
          ;

nolist : /*Empty*/ {dolist = 0;}
yeslist : /*Empty*/ {dolist = 1;}

s_list : NAME {
         sglist * sg;
	   if(dolist){
	     sg=(sglist *) malloc(sizeof(sglist));
             sg->name=$1;
             sg->next=NULL;
             $$=sg;
           } else{
             free($1);
             $$=NULL;
           }
         }
       | NAME ',' s_list {
         sglist * sg;
	   if(dolist){
	     sg=(sglist *) malloc(sizeof(sglist));
             sg->name=$1;
             sg->next=$3;
             $$=sg;
           } else{
             free($1);
             $$=NULL;
           }
         }
       ;

a_body : rem {$$=addind($1);}
       | rem signal '<' '=' sigvalue doothers a_body {
         slist *sl;
           sl=addsl($1,indents[indent]);
           sl=addtxt(sl,"assign ");
           sl=addsl(sl,$2->sl);
           fixothers($2,$6);
           free($2);
           sl=addtxt(sl," = ");
           sl=addsl(sl,$5);
           sl=addtxt(sl,";\n");
           $$=addsl(sl,$7);
         }
       | rem WITH expr SELECT rem yeswith signal '<' '=' with_list doothers a_body {
         slist *sl;
         sglist *sg;
         char *s;

           sl=addsl($1,indents[indent]);
           sl=addtxt(sl,"always@() begin // Sensitivity list is empty\n");
           sl=addsl(sl,indents[indent]);
           sl=addtxt(sl,"  case(");
           sl=addsl(sl,$3->sl);
           free($3);
           sl=addtxt(sl,")\n");
           if($5)
             sl=addsl(sl,$5);
	   s=bottom($7->sl);
           if((sg=lookup(io_list,s))==NULL)
             sg=lookup(sig_list,s);
           if(sg)
             sg->type=reg;
           fixothers($7,$11);
           free($7);
           sl=addsl(sl,$10);
           sl=addsl(sl,indents[indent]);
           sl=addtxt(sl,"  endcase\n");
           sl=addsl(sl,indents[indent]);
           sl=addtxt(sl,"end\n\n");
           $$=addsl(sl,$12);
         }
       | rem NAME ':' NAME PORT MAP '(' doindent map_list ')' ';' unindent a_body {
         slist *sl;
           sl=addsl($1,indents[indent]);
           sl=addtxt(sl,$4);
           sl=addtxt(sl," ");
           sl=addtxt(sl,$2);
           sl=addtxt(sl,"(\n");
           sl=addsl(sl,indents[indent]);
           sl=addsl(sl,$9);
           sl=addtxt(sl,");\n\n");
           $$=addsl(sl,$13);
         }
       | optname PROCESS '(' sign_list ')' p_decl BEGN doindent p_body END PROCESS oname ';' unindent a_body {
         slist *sl;
         char *s;
           sl=addsl($1,indents[indent]);
	   sl=addtxt(sl,"always @(");
           sl=addsl(sl,$4);
	   sl=addtxt(sl,") begin");
           if($6){
             sl=addtxt(sl," : P");
             s=(char *) malloc(6*sizeof(char));
             sprintf(s,"%d\n",np++);
             sl=addtxt(sl,s);
             sl=addsl(sl,$6);
           }
	   sl=addtxt(sl,"\n");
           sl=addsl(sl,$9);
           sl=addsl(sl,indents[indent]);
           sl=addtxt(sl,"end\n\n");
           $$=addsl(sl,$15);
         }
       | optname PROCESS '(' sign_list ')' p_decl BEGN doindent
           rem IF edge THEN p_body END IF ';'
           END PROCESS oname ';' unindent a_body {
           slist *sl;
           char *s;
             sl=addsl($1,indents[indent]);
	     sl=addtxt(sl,"always @(");
             if(clkedge)
	       sl=addtxt(sl,"posedge ");
             else
	       sl=addtxt(sl,"negedge ");
	     sl=addtxt(sl,clkname);
	     sl=addtxt(sl,") begin");
             if($6){
               sl=addtxt(sl," : P");
               s=(char *) malloc(6*sizeof(char));
               sprintf(s,"%d\n",np++);
               sl=addtxt(sl,s);
               sl=addsl(sl,$6);
             }
	     sl=addtxt(sl,"\n");
             if($9){
               sl=addsl(sl,indents[indent]);
               sl=addsl(sl,$9);
	     }
             sl=addsl(sl,$13);
             sl=addsl(sl,indents[indent]);
             sl=addtxt(sl,"end\n\n");
             $$=addsl(sl,$22);
         }
       | optname PROCESS '(' sign_list ')' p_decl BEGN doindent
           rem IF exprc THEN doindent p_body unindent ELSIF edge THEN doindent p_body unindent END IF ';'
           END PROCESS oname ';' unindent a_body {
           slist *sl;
           char *s;
             sl=addsl($1,indents[indent]);
	     sl=addtxt(sl,"always @(");
             if(clkedge)
	       sl=addtxt(sl,"posedge ");
             else
	       sl=addtxt(sl,"negedge ");
	     sl=addtxt(sl,clkname);
             if($11->data.sl->data.txt[0]-'0')
	       sl=addtxt(sl," or posedge ");
             else
	       sl=addtxt(sl," or negedge ");
	     sl=addtxt(sl,$11->slst->slst->data.txt);
	     sl=addtxt(sl,") begin");
             if($6){
               sl=addtxt(sl," : P");
               s=(char *) malloc(6*sizeof(char));
               sprintf(s,"%d\n",np++);
               sl=addtxt(sl,s);
               sl=addsl(sl,$6);
             }
	     sl=addtxt(sl,"\n");
             if($9){
               sl=addsl(sl,indents[indent]);
               sl=addsl(sl,$9);
	     }
             sl=addsl(sl,indents[indent]);
             sl=addtxt(sl,"  if(");
             sl=addsl(sl,$11);
	     sl=addtxt(sl,") begin\n");
             sl=addsl(sl,$14);
             sl=addsl(sl,indents[indent]);
             sl=addtxt(sl,"  end else begin\n");
             sl=addsl(sl,$20);
             sl=addsl(sl,indents[indent]);
             sl=addtxt(sl,"  end\n");
             sl=addsl(sl,indents[indent]);
             sl=addtxt(sl,"end\n\n");
             $$=addsl(sl,$30);
         }
       ;

oname : {$$=NULL;}
      | NAME {free($1); $$=NULL;}
      ;

optname : rem {$$=$1;}
        | rem NAME ':' {$$=$1; free($2);}
        ;

edge : NAME '\'' EVENT AND exprc {
         clkname=$1;
         clkedge=$5->data.txt[0]-'0';
         /* slfree($5); */
       }
     | exprc AND NAME '\'' EVENT {
         clkname=$3;
         clkedge=$1->data.txt[0]-'0';
         /* slfree($1); */
       }
     | POSEDGE '(' NAME ')' {
         clkname=$3;
         clkedge=1;
       }
     | NEGEDGE '(' NAME ')' {
         clkname=$3;
         clkedge=0;
       }
     ;

yeswith : {dowith=1;}

doothers : {
             slist *sl;
               sl=(slist *) malloc(sizeof(slist));
               sl->slst=others0;
               sl->data.sl=others1;
               others0=NULL;
               $$=sl;
            }

with_list : with_item ';' {$$=$1;}
          | with_item ',' rem with_list {
            slist *sl;
	      if($3){
                sl=addsl($1,$3);
                $$=addsl(sl,$4);
              } else
                $$=addsl($1,$4);
            }
          | expr delay WHEN OTHERS ';' {
            slist *sl;
	      sl=addtxt(indents[indent],"    default : ");
              sl=addsl(sl,slwith);
	      sl=addtxt(sl," <= ");
	      if(delay && $2){
                sl=addtxt(sl,"# ");
                sl=addval(sl,$2);
                sl=addtxt(sl," ");
              }
              if($1->op == 'c')
                sl=addsl(sl,addwrap("{",$1->sl,"}"));
              else
                sl=addsl(sl,$1->sl);
              free($1);
              delay=1;
	      $$=addtxt(sl,";\n");
            }

with_item : expr delay WHEN wlist {
            slist *sl;
	      sl=addtxt(indents[indent],"    ");
	      sl=addsl(sl,$4);
	      sl=addtxt(sl," : ");
              sl=addsl(sl,slwith);
	      sl=addtxt(sl," <= ");
	      if(delay && $2){
                sl=addtxt(sl,"# ");
                sl=addval(sl,$2);
                sl=addtxt(sl," ");
              }
              if($1->op == 'c')
                sl=addsl(sl,addwrap("{",$1->sl,"}"));
              else
                sl=addsl(sl,$1->sl);
              free($1);
              delay=1;
	      $$=addtxt(sl,";\n");
            }

p_decl : rem {$$=$1};
       | rem VARIABLE s_list ':' type ';' p_decl {
         slist *sl;
         sglist *sg, *p;
	   sl=addtxt($1,"    reg ");
           sl=addpar(sl,$5);
           free($5);
           sg=$3;
           for(;;){
             sl=addtxt(sl,sg->name);
             p=sg;
             sg=sg->next;
             free(p);
             if(sg)
               sl=addtxt(sl,",");
             else
               break;
           }
           sl=addtxt(sl,";\n");